def move():
global snake, bean, direction, gameover, score, time_interval, timer
if not gameover:
if direction == RIGHT:
head = [snake[0][0]+1, snake[0][1]]
elif direction == UP:
head = [snake[0][0], snake[0][1]-1]
elif direction == LEFT:
head = [snake[0][0]-1, snake[0][1]]
elif direction == DOWN:
head = [snake[0][0], snake[0][1]+1]
# 检查游戏结束条件
if head[0] >= COLS or head[0] < 0 or head[1] >= ROWS or head[1] < 0 or (head in snake):
gameover = True
return
snake.insert(0, head)
tail = snake.pop()
if bean in snake: # 如果吃到豆子
bean = create_bean()
snake.append(tail)
score += 1
if score > 0 and score % 5 == 0 and time_interval > 50:
simplegui.timers.destroy() # 先销毁原有 timer，再创建新的 timer
time_interval /= 1.2
timer = simplegui.create_timer(time_interval, move)
timer.start()
def process_bonus(bonus):
global lives, explosion_group, cant_rocks, rock_group, timer3, score, \
immortal, scoreBonus, seconds, functionTimer
if bonus.type == 3: # lives++
lives += 1
elif bonus.type == 4: # exploit all the asteroids
copy = rock_group.copy()
for i in copy:
explosion_group.add(Sprite(i.get_position(), [0, 0], 0, 0,
explosion_image, explosion_info,
WIDTH, HEIGHT, explosion_sound))
rock_group.discard(i)
cant_rocks -= 1
score += 1
else:
if bonus.type == 2: #each asteroid is +2
scoreBonus = True
immortal = False
elif bonus.type == 1: #the asteroids not hurt you
immortal = True
scoreBonus = False
if timer3 is not None:
timer3.stop()
seconds = 0
timer3 = simplegui.create_timer(1000, timer_bonus_1_2)
tick_tock_sound.rewind()
tick_tock_sound.play()
timer3.start()
def main():
global TIME_INTERVAL, frame, timer
#create a timer with timed event
timer = simplegui.create_timer(TIME_INTERVAL, incrementTime)
#create frame
frame = createFrame()
#start frame
frame.start()
def reset():
""" Reset stopwatch and score """
global timer, counter, message, attempts, hits, is_running, sucs_message
timer.stop()
is_running = False
timer = simplegui.create_timer(100, tick)
counter = 0
attempts = 0
hits = 0
sucs_message = ""
def play():
global snake, bean, direction, gameover, score, time_interval, timer
# 如果有正在运行的定时器，需要先把它停下
if timer is not None and timer.is_running():
timer.stop()
# 创建定时器
timer = simplegui.create_timer(time_interval, move)
timer.start()
# 代码写在下面
pass
def timer_handler():
global x
x += 4
print x
print time.time()
print ""
global timer
if x >= 16:
timer.stop()
timer = simpleguitk.create_timer(500, timer_handler)
timer.start()
def createWorld(self):
world = gui.create_frame("Robot World",self.worldX,self.worldY)
world.set_canvas_background(GUI.WORLD_COLOR)
self.txtSetDist = world.add_input("Set Distance", self.txtDestDistance,50)
self.btnSetDist = world.add_button("Set Distance",self.setDistHandler,50)
self.btnMove = world.add_button("Move",self.moveHandler, 50)
timer = gui.create_timer(500,self.timerHandler)
world.set_draw_handler(self.renderingHandler)
timer.start()
world.start()
def play():
global snake, bean, direction, gameover, score, time_interval, timer
# 如果有正在运行的定时器，需要先把它停下
if timer is not None and timer.is_running():
timer.stop()
# 创建定时器
timer = simplegui.create_timer(time_interval, move)
timer.start()
snake = create_snake()
bean = create_bean()
direction = LEFT
score = 0
gameover = False
time_interval = 200
def createWorld(self):
world = gui.create_frame("Robot World", self.worldX, self.worldY)
world.set_canvas_background(GUI.WORLD_COLOR)
self.txtSetDist = world.add_input("Set Distance", self.txtDestDistance,
50)
self.btnSetDist = world.add_button("Set Distance", self.setDistHandler,
50)
self.btnMove = world.add_button("Move", self.moveHandler, 50)
timer = gui.create_timer(500, self.timerHandler)
world.set_draw_handler(self.renderingHandler)
timer.start()
world.start()
def __init__(self, puzzle):
"""
Create frame and timers, register event handlers
"""
self._puzzle = puzzle
self._puzzle_height = puzzle.get_height()
self._puzzle_width = puzzle.get_width()
self._frame = simplegui.create_frame("The Fifteen puzzle",
self._puzzle_width * TILE_SIZE,
self._puzzle_height * TILE_SIZE)
self._solution = ""
self._current_moves = ""
self._frame.add_button("Solve", self.solve, 100)
self._frame.add_input("Enter moves", self.enter_moves, 100)
self._frame.add_button("Print moves", self.print_moves, 100)
self._frame.set_draw_handler(self.draw)
self._frame.set_keydown_handler(self.keydown)
self._timer = simplegui.create_timer(50, self.tick)
self._timer.start()
self._frame.start()
# 按键事件响应函数
def keydown(key):
global score
try:
ch = chr(key)
except: # 捕捉 TypeError 或其它异常
return # 不做任何处理
else:
pass
# 代码填在这里
# 换一个词
def change_word():
global word, flag, pointer, score
pass
# 创建用户界面
frame = simplegui.create_frame("疯狂英语", WIDTH, HEIGHT)
frame.set_canvas_background("White")
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
# 创建按钮
frame.add_button("开始游戏", play, 80)
# 创建定时器
timer = simplegui.create_timer(TIME_INTERVAL, change_word)
play()
frame.start()
def demo1():
# Register handler
timer = simplegui.create_timer(1000, tick)
# Start timer
timer.start()
new_game()
return
def restart_game():
print("Restarting Game....")
timer.start()
def timer_man():
print(" \n\tLet's Play! ")
timer.stop()
new_game()
#Frame Definition
frame = simplegui.create_frame("Guess The Number!", 250, 250)
frame.set_canvas_background('Blue')
timer = simplegui.create_timer(1500, timer_man)
# register event handlers for control elements and start frame
frame.start()
frame.add_input("Enter the number", input_guess, 200)
frame.add_button("Change to range(0-1000)", range1000, 200)
frame.add_button("Change to range(0-100)", range100, 200)
frame.add_button("Restart this game", restart_game, 200)
# call new_game
new_game()
node.set_colour('inactive')
elif node.colour == 'black':
node.set_colour('visited')
current = queue.pop(0)
lbl_current.set_text('Corrente: ' + str(current + 1))
node_list[current].set_colour('current')
if current == goal:
complete = True
lbl_found.set_text('Encontrado: ' + str(complete))
else:
for child in node_list[current].children:
node_list[child].set_colour('active')
if child not in discarded:
queue.append(child)
lbl_queue.set_text('Fila: ' + str(queue))
if current not in discarded:
discarded.append(current)
else:
reset()
frame = simplegui.create_frame("BFS", B_WIDTH, B_HEIGHT)
frame.set_canvas_background('GREY')
frame.set_draw_handler(draw)
lbl_queue = frame.add_label('Fila: ' + str(queue))
lbl_current = frame.add_label('Corrente: ')
lbl_found = frame.add_label('Encontrado: ' + str(complete))
timer = simplegui.create_timer(1000, step)
timer.start()
frame.start()
if key == simplegui.KEY_MAP["left"] and direction != "right":
direction = "left"
velocity_change.append([-1,0])
if key == simplegui.KEY_MAP["right"] and direction != "left":
direction = "right"
velocity_change.append([1,0])
if key == simplegui.KEY_MAP["up"] and direction != "down":
direction = "up"
velocity_change.append([0,-1])
if key == simplegui.KEY_MAP["down"] and direction != "up":
direction = "down"
velocity_change.append([0,1])
# create frame
frame = simplegui.create_frame("Snake", FRAME_WIDTH, FRAME_HEIGHT, 150)
frame.set_canvas_background("#000")
# event handlers
frame.set_draw_handler(draw_handler)
frame.set_keydown_handler(keydown_handler)
lenght_label = frame.add_label("Lenght: " + str(lenght))
score_label = frame.add_label("Score: " + str(score))
last_score_label = frame.add_label("Last score: " + str(last_score))
high_score_label = frame.add_label("Hightest score: " + str(high_score))
move_timer = simplegui.create_timer(150, move_handler)
food_timer = simplegui.create_timer(6000, food_handler)
blink_timer = simplegui.create_timer(100, blink_handler)
# start frame
frame.start()
init()
y = height / 2 + font_size_time / 2
canvas.draw_text(str_time, [x, y], font_size_time, font_color_time)
x = 0.75 * width
y = 0.25 * height
str_game = "%d/%d" % (nbr_win, nbr_stop_watch)
canvas.draw_text(str_game, [x, y], font_size_game, font_color_game)
# define event handler for timer with 0.1 sec interval
def time_handler():
global time
time += 1
# create frame
frame = simplegui.create_frame("Stopwatch: The Game", width, height)
button_start = frame.add_button("Start", start_handler, 100)
button_stop = frame.add_button("Stop", stop_handler, 100)
button_reset = frame.add_button("Reset", reset_handler, 100)
# register draw handler
frame.set_draw_handler(draw)
# register event handlers
timer = simplegui.create_timer(interval, time_handler)
# start timer and frame
timer.start()
frame.start()
# keyboard input handlers:
def checkKeyUp(key):
my_ship.keyUp(key)
# timer handler that spawns a rock
def rock_spawner():
pass
# initialize frame
frame = simplegui.create_frame("Asteroids", width, height)
# initialize ship and two sprites
my_ship = Ship([width / 2, height / 2], [0, 0], 0, ship_image, ship_info)
a_rock = Sprite([width / 3, height / 3], [1, 1], 0, 0, asteroid_image,
asteroid_info)
a_missile = Sprite([2 * width / 3, 2 * height / 3], [-1, 1], 0, 0,
missile_image, missile_info, missile_sound)
# register handlers
frame.set_draw_handler(draw)
frame.set_keyup_handler(checkKeyUp)
timer = simplegui.create_timer(1000.0, rock_spawner)
# get things rolling
timer.start()
frame.start()
def incrementar():
global contador
contador = contador +1
#definir los manejadores de eventos
def tick():
incrementar()
def button_press():
global contador
contador=0
def mostrar(texto):
tick()
texto.draw_text(contador,[50,50],10,"Red")
#Crear el marco(frame)
#create_frame funcion que pertenece al modulo simplegui
#sintaxis create_frame('titulo del marco', ancho (weight), largo(height))
marco = simplegui.create_frame("Primer Programa con SimpleGUI", 100,100)
#registrar los manejadores de eventos
temporizador = simplegui.create_timer(1000,mostrar)
marco.add_button("Resetear Contador", button_press)
marco.set_draw_handler(mostrar)
#comenzar los timers y frames
marco.start()
#temporizador.start()
timer.stop()
inplay = True
grid = Grid()
score = 0
current_shape = create_shape()
timer.start()
def keydown(key):
if key == simplegui.KEY_MAP['space']:
current_shape.rotate(grid)
if key == simplegui.KEY_MAP['left']:
current_shape.move('left', grid)
if key == simplegui.KEY_MAP['right']:
current_shape.move('right', grid)
if key == simplegui.KEY_MAP['down']:
current_shape.move('down', grid)
# 创建用户界面
frame = simplegui.create_frame("俄罗斯方块", WIDTH, HEIGHT)
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
# 创建按钮
frame.add_button("开始游戏", play, 80)
# 创建定时器
timer = simplegui.create_timer(TIME_INTERVAL, move)
play()
frame.start()
# define event handler for timer with 0.1 sec interval
def elapse():
global time_general
time_general += 1
format(time_general)
# define draw handler
def draw(canvas):
canvas.draw_text(time_string, [40, 120], 50, "White")
canvas.draw_text(score_string, [130, 32], 40, "Green")
# create frame
frame = simplegui.create_frame('Stopwatch', 200, 200)
# register event handlers
frame.add_button('Start', start, 120)
frame.add_label('')
frame.add_button('Stop', stop, 120)
frame.add_label('')
frame.add_button('Reset', reset, 120)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(100, elapse)
# start frame
frame.start()
# Please remember to review the grading rubric
#definir los manejadores de eventos
def tick():
incrementar()
def button_press():
global contador
contador = 0
def mostrar(texto):
tick()
texto.draw_text(contador, [50, 50], 10, "Red")
#Crear el marco(frame)
#create_frame funcion que pertenece al modulo simplegui
#sintaxis create_frame('titulo del marco', ancho (weight), largo(height))
marco = simplegui.create_frame("Primer Programa con SimpleGUI", 100, 100)
#registrar los manejadores de eventos
temporizador = simplegui.create_timer(1000, mostrar)
marco.add_button("Resetear Contador", button_press)
marco.set_draw_handler(mostrar)
#comenzar los timers y frames
marco.start()
#temporizador.start()
pad_pos[1] = GAME_HEIGHT - HALF_PAD_HEIGHT
if pad_pos[1] < HALF_PAD_HEIGHT:
pad_pos[1] = HALF_PAD_HEIGHT
return pad_pos
def update_pad():
"""每个时间间隔调用此函数即可生成球拍的动态效果"""
global PAD_L_POS, PAD_R_POS
PAD_L_POS[1] += pad_ai(PAD_L_POS, BALL_POS) * PAD_SPEED
PAD_R_POS[1] += pad_ai(PAD_R_POS, BALL_POS) * PAD_SPEED
PAD_L_POS = pad_limit(PAD_L_POS)
PAD_R_POS = pad_limit(PAD_R_POS)
def timer_handler():
update_ball()
update_pad()
#创建游戏界面
frame = simplegui.create_frame("PingPang2", GAME_WIDTH, GAME_HEIGHT)
frame.set_draw_handler(draw) #初始化界面
timer = simplegui.create_timer(INTERVAL,
timer_handler) #定义刷新频率，连接刷新时执行的动作，产生动画效果
ball_init() #初始化球的参数
pad_init() #初始化挡板参数
timer.start() #开始刷新
frame.start() #开始绘制图形
##> Define Classes
##> Define Event Handlers
def draw(canvas):
canvas.draw_text(str(time), [50, 60], 12, "Gray", "Monospace")
return
def TimeInc():
global time
time = time + 1
##> Create Frame
frame = simplegui.create_frame("SimpleGUI", 150, 100)
timer = simplegui.create_timer(10, TimeInc)
# The first paremeter is time in milliseconds
# The second parameter is the function to run each time
##> Register Event Handlers
frame.set_draw_handler(draw)
##> Start Frame and Timers
timer.start()
frame.start()
height = 500
frame = gui.create_frame('Game', 600, height)
r = 30 # радиус мяча
point = [20, 20] # центр мяча
acc = [2, 3] # ускорение по гризонтали и вертикали
def draw(canvas):
canvas.draw_circle(point, r, 1, 'Red', 'Red')
def timer_handler():
global time # объявляю для изменения глобальной переменной
time += 1
print('timer', time)
point[0] += acc[0]
point[1] += acc[1]
print("point: ", point)
# пересечение нижней границы холста
if point[1] + r > height:
acc[1] = -acc[1]
frame.set_draw_handler(draw)
timer = gui.create_timer(1000 // 60, timer_handler)
timer.start()
frame.start()
format(seconds)
#定义定时器增加秒钟函数
def second_add():
#每点击一次增加10，这里的10相当于1秒。
global seconds
seconds += 10
format(seconds)
#定义绘制画布函数
def draw(canvas):
#画布中绘制文本
global message1, message2
canvas.draw_text(message2 , [260, 50], 40, "Green")
canvas.draw_text(message1 , [160, 200], 60, "White")
frame = simplegui.create_frame("秒表、计时器", 600, 400) #创建框架
timer1 = simplegui.create_timer(100, tick1) #创建时间触发器1，每0.1秒更新一次tick1
timer2 = simplegui.create_timer(100, tick2) #创建时间触发器2，每0.1秒更新一次tick2
# register event handlers
frame.add_button("秒表开始", start1, 150) #框架上增加”秒表开始“按钮
frame.add_button("暂停", stop, 150) #框架上增加”暂停“按钮
frame.add_button("复位", reset, 150) #框架上增加”复位“按钮
frame.add_button("定时器开始",start2, 150 ) #框架上增加”计时器按钮“按钮
frame.add_button("加分钟",minut_add, 150 ) #框架上增加”加分钟“按钮
frame.add_button("加秒钟",second_add, 150 ) #框架上增加”加秒钟“按钮
frame.set_draw_handler(draw) #执行画布绘制
#框架开始执行
frame.start()
# draw handler
def draw(canvas):
global tick, tries, win
timer = format(tick)
score = str(win) + " / " + str(tries)
canvas.draw_text(timer, [70, 70], 18, "White")
canvas.draw_text(score, [145, 15], 14, "Green")
# create frame
frame = simplegui.create_frame("Stopwatch: The Game", 200, 120)
# register event handlers
timer = simplegui.create_timer(100, update)
start = frame.add_button("Start", start, 50)
stop = frame.add_button("Stop", stop, 50)
reset = frame.add_button("Reset", reset, 50)
frame.set_draw_handler(draw)
# start timer and frame
frame.start()
# remember to review the grading rubric
#print "Some tests:"
#print "Outcome | Expected"
#print " "+format(0)+" = 0:00.0"
#print " "+format(11)+" = 0:01.1"
#print " "+format(321)+" = 0:32.1"
#print " "+format(613)+" = 1:01.3"
def increment():
global tenth_sec
tenth_sec += 1
# define draw handler
def draw(canvas):
global tenth_sec
global flag
canvas.draw_text( format(tenth_sec), [100,100], 24, "White")
canvas.draw_text( game(), [150,20], 24, "White")
# create frame
f=simplegui.create_frame("",200,200)
# register event handlers
timer=simplegui.create_timer(100,increment)
f.add_button("Start",start,100)
f.add_button("Stop",stop,100)
f.add_button("Reset",reset,100)
f.set_draw_handler(draw)
# start frame
f.start()
# Please remember to review the grading rubric
running=False
# define event handler for timer with 0.1 sec interval
def elapse():
global time_general
time_general+=1
format(time_general)
# define draw handler
def draw(canvas):
canvas.draw_text(time_string, [40, 120], 50, "White")
canvas.draw_text(score_string, [130, 32], 40, "Green")
# create frame
frame=simplegui.create_frame('Stopwatch', 200, 200)
# register event handlers
frame.add_button('Start', start, 120)
frame.add_label('')
frame.add_button('Stop', stop, 120)
frame.add_label('')
frame.add_button('Reset', reset, 120)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(100, elapse)
# start frame
frame.start()
# Please remember to review the grading rubric
def button_reset():
"""Resets the stopwatch by setting the time to 0 and the stopwatch counters to 0"""
global time, stop_counter, stop_hits
stopwatch.stop()
time = 0
stop_counter = 0
stop_hits = 0
def tick():
"""Timer handler which simply increments the time variable by one"""
global time
time += 1
def draw(canvas):
"""Draw handler which draws the formatted value of time and the score using the stopwatch counters"""
canvas.draw_text(format(time), [100, 100], 24, "White")
canvas.draw_text(
str(stop_hits) + "/" + str(stop_counter), [250, 50], 24, "Green")
#Register event handlers, create frame and timers, and start the frame
frame = simplegui.create_frame("Stopwatch", 300, 200)
stopwatch = simplegui.create_timer(interval, tick)
frame.set_draw_handler(draw)
frame.add_button("Start", button_start, button_width)
frame.add_button("Stop", button_stop, button_width)
frame.add_button("Reset", button_reset, button_width)
frame.start()
def draw(canvas):
canvas.draw_text(str(gallons), [120, 125], 12, "Grey", "Monospace")
canvas.draw_text(str(price), [120, 175], 12, "Green", "Monospace")
canvas.draw_text(StationLabel, [20, 50], 14, "Yellow", "Monospace")
canvas.draw_text(GallonLabel, [20, 125], 12, "Grey", "Monospace")
canvas.draw_text(PriceLabel, [20, 175], 12, "Green", "Monospace")
canvas.draw_text(DollarSignLabel, [100, 175], 12, "Green", "Monospace")
## Frame
frame = simplegui.create_frame("SimpleGUI", 400, 300)
GallonTimer = simplegui.create_timer(10, GallonInc)
StandardPriceTimer = simplegui.create_timer(100, StandardFuel)
PlusPriceTimer = simplegui.create_timer(100, PlusFuel)
PremiumPriceTimer = simplegui.create_timer(100, PremiumFuel)
Message = frame.add_label("Label")
Message.set_text(
"\n Welcome to the Shell gas station. \n"
"\n Please Select a fuel type \n"
)
Spacer = frame.add_label("")
Spacer.set_text("")
def reset():
timer.stop()
global t
t = 0
def draw(canvas):
canvas.draw_text(format(t), position, 24, 'White')
canvas.draw_text('Scores', [350, 60], 20, 'Red')
# define event handler for timer with 0.1 sec interval
def tick():
global t
t = t + 1
# create frame
frame = simpleguitk.create_frame('Stop Watch Game ', 500, 500)
timer = simpleguitk.create_timer(interval, tick)
# register event handlers
frame.set_draw_handler(draw)
startButton = frame.add_button('Start', start)
stopButton = frame.add_button('Stop', stop)
resetButton = frame.add_button('Reset', reset)
# start timer and frame
frame.start()
if not (X, Y) == x_goal.point:
X = next_x
Y = next_y
theta = math.radians(next_a)
else:
X = x_goal.point[0]
Y = x_goal.point[1]
counter += 1
if counter == turningFreq:
#theta = math.atan2(next_y-old_y,next_x-old_x)
print "something"
index += 1
counter = 0
# Create frame for rendering
myFrame = simple.create_frame('Curio Simulator', WIDTH, HEIGHT)
# Create timer for updating the positions of robot(s)
tmrUpdate = simple.create_timer(10, timerHandler)
# Attach handler for graphics rendering
myFrame.set_draw_handler(drawHandler)
# Start the timer and rendering
#RG_RRT()
tree = insertNode(x_init, tree, delta_tt)
print "Out of the RG-RRT"
tmrUpdate.start()
myFrame.start()
global time , aciertos, intentos
time = 0
aciertos = 0
intentos = 0
timer.stop()
# define event handler for timer with 0.1 sec interval
def imprimir():
global time
time +=1
# define draw handler
def draw(canvas):
canvas.draw_text(format(time),[60,110],35,"white")
canvas.draw_text(resultados(), [150,20], 24 , "green")
# create frame
marco = simplegui.create_frame("StopWatch", 200,200)
marco.add_button("Start", start, 100)
marco.add_button("Stop", stop, 100)
marco.add_button("Reset", reset, 100)
marco.set_draw_handler(draw)
# register event handlers
timer = simplegui.create_timer(100,imprimir)
# start frame
marco.start()
import simpleguitk as simplegui
def timer1_handler():
print '1'
def timer2_handler():
print '2'
timer1 = simplegui.create_timer(100, timer1_handler)
timer2 = simplegui.create_timer(200, timer2_handler)
timer1.start()
timer2.start()
# stop the paddles on key up
if (key == simplegui.KEY_MAP["w"]) or (key == simplegui.KEY_MAP["s"]):
paddle1_vel = 0
if (key == simplegui.KEY_MAP["up"]) or (key == simplegui.KEY_MAP["down"]):
paddle2_vel = 0
# countdown timer for the start of the game
# when the timer reaches 0 the ball spawns
def timer_countdown():
global countdown
countdown -= 1
if (countdown == 0):
spawn_ball("RIGHT")
timer.stop()
# create frame
frame = simplegui.create_frame("Pong", WIDTH, HEIGHT)
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.add_button(" Restart ", new_game)
# Add a countdown timer to the beginning of the game
timer = simplegui.create_timer(1000, timer_countdown)
new_game()
# start frame
frame.start()
time = 0
aciertos = 0
intentos = 0
timer.stop()
# define event handler for timer with 0.1 sec interval
def imprimir():
global time
time += 1
# define draw handler
def draw(canvas):
canvas.draw_text(format(time), [60, 110], 35, "white")
canvas.draw_text(resultados(), [150, 20], 24, "green")
# create frame
marco = simplegui.create_frame("StopWatch", 200, 200)
marco.add_button("Start", start, 100)
marco.add_button("Stop", stop, 100)
marco.add_button("Reset", reset, 100)
marco.set_draw_handler(draw)
# register event handlers
timer = simplegui.create_timer(100, imprimir)
# start frame
marco.start()
# test
# type = 1
if bonus is not None:
exist = False
for i in bonus_group:
if i.type == type:
exist = True
break
if not exist:
data = getDataPosition()
bonus_group.add(Bonus(data["position"], type, bonus))
# initialize frame
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(mouse_handler)
frame.set_keyup_handler(keyup)
timer = simplegui.create_timer(1000.0, rock_spawner)
timer2 = simplegui.create_timer(10000.0, bonus_spawner)
# get things rolling
timer.start()
timer2.start()
frame.start()
mag_topleft = (mag_left, mag_top)
mag_topright = (mag_right, mag_top)
mag_botleft = (mag_left, mag_bottom)
mag_botright = (mag_right, mag_bottom)
box = [mag_topleft, mag_botleft, mag_botright,
mag_topright, mag_topleft]
canvas.draw_polyline(box, 4, "Blue")
# event handler for timer
def tick():
"""
向右下方移动
"""
magnifier_center[0] += 1
magnifier_center[1] += 1
# 创建框架
frame = simplegui.create_frame("放大镜", CANVAS_WIDTH, CANVAS_HEIGHT)
frame.set_draw_handler(draw)
frame.set_mouseclick_handler(click)
frame.set_mousedrag_handler(drag)
# 计时器
timer = simplegui.create_timer(60.0,tick)
# 开始
magnifier_center = [CANVAS_WIDTH / 2, CANVAS_HEIGHT / 2]
timer.start()
frame.start()
def key_down(key):
if key == simplegui.KEY_MAP["space"]:
game_begin()
def input_handler(text_input):
global lives
if text_input.isdigit():
lives = int(text_input)
# initialize frame
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
inp = frame.add_input('初始阳光:', input_handler, 50)
inp.set_text(1000)
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(key_down)
frame.set_mouseclick_handler(mouseclick)
timer = simplegui.create_timer(random.randint(500, zombie_interval), zombie_spawner)
timer1 = simplegui.create_timer(5000.0, sunshine_spawner)
timer2 = simplegui.create_timer(1000.0, bullet_spawner)
timer3 = simplegui.create_timer(100.0, flower_sunshine_spawner)
# get things rolling
timer.start()
timer1.start()
timer2.start()
timer3.start()
frame.start()
time = 0
success = 0
attempts = 0
# define event handler for timer with 0.1 sec interval
def timer_handler():
global time
time += 1
# define draw handler
def draw(canvas):
global success, attempts
present_time = format()
result = str(success) + "/" + str(attempts)
canvas.draw_text(present_time, [150,150], 40, "Red")
canvas.draw_text(result, [250,50], 30, "Green")
# create frame
frame = simpleguitk.create_frame("Timer", 500, 500)
timer = simpleguitk.create_timer(100, timer_handler)
# register event handlers
frame.add_button("Start", start, 100)
frame.add_button("Stop", stop, 100)
frame.add_button("Reset", reset, 100)
frame.set_draw_handler(draw)
# start frame
frame.start()
print (time)
# Please remember to review the grading rubric
has_Stopped = True
# define event handler for timer with 0.1 sec interval
def tick():
global t, time
t += 1
time = format(t)
# define draw handler
def draw(canvas):
canvas.draw_text(time, [100, 100], 36, "Red")
canvas.draw_text(x + '/' + y, [140, 20], 24, "Green")
# create frame
frame = simplegui.create_frame("StopWatch", 300, 200)
# register event handlers
frame.add_button("Start", start, 200)
frame.add_button("Stop", stop, 200)
frame.add_button("Reset", reset, 200)
frame.set_draw_handler(draw)
timer1 = simplegui.create_timer(interval, tick)
# start frame
frame.start()
# Please remember to review the grading rubric
# timer handler - cuando el usuario pierde
def show_you_lost():
global you_lost_counter, you_lost
you_lost_counter -= 1
if (you_lost == "Black"):
you_lost = "White"
else:
you_lost = "Black"
if (you_lost_counter <= 0):
timerLost.stop()
init() # inicia nuevo juego
# frame
f = simpleguitk.create_frame("Hangman", 1000, 640)
# registro de eventos
txtGuess = f.add_input("Ingresa tu letra: (Presione Enter)", get_input, 200)
timerWon = simpleguitk.create_timer(100, show_you_won)
timerLost = simpleguitk.create_timer(1000, show_you_lost)
button = f.add_button("Nuevo juego", init)
f.set_draw_handler(draw)
# start frame
f.start()
# start game
init()
# 定义绘制屏幕的处理函数
def draw(canvas):
draw_field(canvas)
for i in range(8):
if player_position[i] <= width - end_width - text_width:
player_position[i] = player_position[i] + player_velocity[i]
player_finish_time[i] = disp_format(time_elapsed)[2:]
else:
canvas.draw_text(player_finish_time[i], [width - end_width + 26, (i+1) * height // 8], 24, "Yellow")
canvas.draw_text(player_name[i], [player_position[i], (i+1) * height // 8], 24, "White")
time.set_text(disp_format(time_elapsed))
# 创建窗口框架
frame = simplegui.create_frame("百米赛跑", width, height)
# 注册事件处理器
frame.add_button("各就位", reset, 25)
frame.add_button("开始跑", start, 25)
time = frame.add_label(disp_format(time_elapsed))
frame.set_draw_handler(draw)
timer = simplegui.create_timer(interval, tick)
# 启动时钟
timer.start()
# 启动窗口
frame.set_canvas_background('Maroon')
init()
frame.start()
def update_msg(text):
global message
message = text
# define handler for timer
def new_position():
global position
x = random.randrange(0, width)
y = random.randrange(0, height)
position[0] = x
position[1] = y
# def handler to draw on canvas
def draw(canvas):
canvas.draw_text(message, position, 26, "Red")
#5. create a frame
frame = simplegui.create_frame('Home', width, height)
#6. register event handlers
text = frame.add_input("Message:", update_msg, 150)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(interval, new_position) #time_in_ms, fxn
#7. start timer first, then frame
timer.start()
frame.start()
rock_vel = [random.random() * 2 * max_speed - max_speed, random.random() * 2 * max_speed - max_speed]
rock_avel = random.random() * .2 - .1
a_rock = Sprite(rock_pos, rock_vel, 0, rock_avel, asteroid_image[random.randrange(len(asteroid_image))], asteroid_info)
minimum_distance = a_rock.get_radius() + my_ship.get_radius()
distance = dist(a_rock.get_position(), my_ship.get_position())
# spawn rock only if distance big enough
if SAFE_DISTANCE_MULT * minimum_distance < distance and not is_group_collide(rock_group, a_rock):
rock_group.add(a_rock)
# initialize stuff
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
# initialize ship and empty sets of rocks and missiles
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
#a_rock = Sprite([WIDTH / 3, HEIGHT / 3], [1, 1], 0, .1, asteroid_image, asteroid_info)
rock_group = set() #Should call it BEATLES
#a_missile = Sprite([2 * WIDTH / 3, 2 * HEIGHT / 3], [-1,1], 0, 0, missile_image, missile_info, missile_sound)
missile_group = set()
explosion_group = set()
# register handlers
frame.set_keyup_handler(keyup)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(1000.0, rock_spawner)
# get things rolling
timer.start()
frame.start()
def draw(canvas):
line_width = random.randrange(0,6,2)
line_color = random.choice(color_list)
fill_color = random.choice(color_list)
font_color = random.choice(color_list)
if choice ==1:
radius = random.randint(1,10)
circle_x = random.randrange(radius, WIDTH-radius)
circle_y = WIDTH/2 * random.random()
radius = random.randint(1,20)
canvas.draw_circle([circle_x,circle_y], radius, line_width, line_color, fill_color)
if choice == 2:
point_list = [[random.randrange(0, WIDTH),random.randint(0,HEIGHT)],[WIDTH/2,HEIGHT/2]]
canvas.draw_polygon(point_list, line_width, line_color, fill_color)
if choice == 3:
point =[random.randrange(0, WIDTH),random.randint(0,HEIGHT)]
font_size = random.choice([6,8,12,24,36,64])
canvas.draw_text(text, point, font_size, font_color)
frame = simplegui.create_frame("屏幕保护程序",400, 400)
frame.add_button("画圆效果", click1, 50)
frame.add_button("折线效果", click2, 50)
frame.add_button("文字效果", click3, 50)
frame.add_input("请输入出现在屏保上的文字：",input,100)
frame.add_button("清空", pause, 50)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(5000,timer_handler)
frame.start()
7: "Enter",
8: "Leave",
9: "FocusIn",
10: "FocusOut",
12: "Expose",
15: "Visibility",
17: "Destroy",
18: "Unmap",
19: "Map",
21: "Reparent",
22: "Configure",
24: "Gravity",
26: "Circulate",
28: "Property",
32: "Colormap",
36: "Activate",
37: "Deactivate",
38: "MouseWheel"
}
'''
can.bind('<Enter>', enterB)
can.bind('<Leave>', leaveB)
can.bind('<Motion>', overB)
timer = simplegui.create_timer(500, timex)
timer.start()
print '\033[1;37m'
frame.start()
num_tries = 0
num_success = 0
is_stopped = True
# define event handler for timer with 0.1 sec interval
def timer_handler():
global tenth_seconds
tenth_seconds = tenth_seconds + 1
# define draw handler
def draw_handler(canvas):
canvas.draw_text(str(num_success)+ "/" + str(num_tries), [230, 30], 24, "Black")
canvas.draw_text(format(tenth_seconds), [80, 150], 50, "Black")
# create frame
frame = simplegui.create_frame("Home", 300, 300)
# register event handlers
timer = simplegui.create_timer(100, timer_handler)
frame.set_draw_handler(draw_handler)
frame.set_canvas_background("White")
frame.add_button("Start", start_button_handler)
frame.add_button("Stop", stop_button_handler)
frame.add_button("Reset", reset_button_handler)
# start frame
frame.start()
# Please remember to review the grading rubric
# define event handler for timer with 0.1 sec interval
def create_timer():
global counter
counter += 1
# define draw handler
def draw_handler(canvas):
timer_text = format(counter)
canvas.draw_text(timer_text, position, 40, 'white')
canvas.draw_text(reflex_counter1 + "/" + reflex_counter2, [240, 50], 26,
'red')
# create frame
frame = simplegui.create_frame("Stopwatch", 300, 200)
# register event handlers
timer = simplegui.create_timer(interval, create_timer)
frame.set_draw_handler(draw_handler)
button1 = frame.add_button('Start timer', start)
button2 = frame.add_button('Stop timer', stop)
button3 = frame.add_button('Reset', reset)
# start frame
frame.start()
# Please remember to review the grading rubric
# 为游戏开始或重新开始初始化全局变量，也是鼠标点击按钮的事件处理函数
def start_game():
global prime_sentence_list, stopped_box, rising_box,current_section_list, has_rising_box, game_over, score, last_four_box
score = 0
label.set_text("游戏得分 = 0分")
game_over = False
prime_sentence_list = read_from_file('三字经.txt')
stopped_box = set([])
last_four_box = []
current_section_list = generate_current_section_list()
rising_sentence = current_section_list.pop()
rising_box = Box([0,canvas_height], box_width, box_height, text_shuffle(rising_sentence[1:]), rising_sentence[1:], int(rising_sentence[0]))
has_rising_box = True
# 创建窗口初始化画布
frame = simplegui.create_frame("挑战《三字经》", canvas_width, canvas_height)
label = frame.add_label("游戏得分 = 0分")
# 注册事件处理函数
frame.set_keydown_handler(keydown) # 按键处理，每次按键会调用keydown函数
frame.set_draw_handler(draw) # 显示处理，每秒调用draw函数60次
timer = simplegui.create_timer(1000.0, box_spawner) # 每秒调用box_spawner函数1次
button = frame.add_button('重新开始游戏', start_game, 100) # 鼠标每次点击“重新开始游戏”按钮，调用start_game函数1次
# 启动游戏
start_game() # 为游戏开始或重新开始初始化全局变量
timer.start() # 启动定时器
frame.start() # 显示窗口
canvas.draw_text('SHUFFLE!!!', (450, 500), 30, 'Black')
canvas.draw_text(str(20 - shuffle_steps), (500, 550), 50, 'Black')
frame = simpleguitk.create_frame("Rubiks Cube!", 600, 600)
frame.add_button("Auto Rotation", rot)
frame.add_button("Stop Rotation", rot_stop)
frame.add_button("Shuffle!", shuffle)
frame.add_button("Rotate Up", rotate_up)
frame.add_button("Rotate Down", rotate_down)
frame.add_button("Next Axis", next_side)
frame.add_button("Last Axis", former_side)
frame.add_button("Reset", reset)
frame.set_draw_handler(draw)
frame.set_canvas_background('grey')
frame.set_mousedrag_handler(mouse_handler)
frame.set_mouseclick_handler(mouse_click_handler)
rotate_timer = simpleguitk.create_timer(50, rotate_cube_timer)
rotate_timer_axis = simpleguitk.create_timer(25, rotate_cube_timer_axis)
shuffle_timer = simpleguitk.create_timer(1000, shuffle_timer_fct)
frame.set_keydown_handler(key_down)
label = frame.add_label(label)
frame.start()
# define event handler for timer with 0.1 sec interval
def timerhandler():
global timer_counter
timer_counter +=1
return
# define draw handler
def draw_handler(canvas):
canvas.draw_text(format(timer_counter), (CANVAS_WIDTH//2, CANVAS_HEIGHT//2), FONT_SIZE, "Red")
score="Score: "+ convert(success_counter)+"/"+ convert(stop_counter)
canvas.draw_text(score, (10,20), FONT_SIZE_SCORE, "White")
# create frame
frame = simplegui.create_frame("Stopwatch", CANVAS_WIDTH, CANVAS_HEIGHT)
# register event handlers
timer = simplegui.create_timer(10, timerhandler)
frame.set_draw_handler(draw_handler)
start_button = frame.add_button("Start", start_handler, 100)
stop_button = frame.add_button("Stop", stop_handler, 100)
reset_button = frame.add_button("Reset", reset_handler, 100)
# start frame
frame.start()
# Please remember to review the grading rubric
f.write("%f\t" % theta1)
f.write("%f\t" % theta2)
f.write("%f\t" % omega1)
f.write("%f" % omega2)
f.write("\n")
#########################################################
# Simulation script:
frame = simplegui.create_frame("Acrobot simulator", CANVAS_WIDTH,
CANVAS_HEIGHT)
frame.set_draw_handler(drawAcrobot)
frame.set_canvas_background("White")
# Create timers
timer = simplegui.create_timer(TIME_STEP * 1000, update)
# Register event handlers
# frame.add_button("Add robot", addRobotButtonClick, 100)
frame.add_button("Reset", reset, 100)
frame.add_button("Quit", quit, 100)
# Create controller
controller = controllerClass()
# Start
#reset()
timer.start()
frame.start()
hits = 0
timer.stop()
# Event handler for timer with 0.1 sec interval
def start_timer():
global started, time
if started == True:
time += 1
# Draw handler
def draw(canvas):
canvas.draw_text(format(time), [80, 170], 40, "Teal")
canvas.draw_text(str(hits) + "/" + str(count), [225, 45], 20, "Magenta")
# Create frame
frame = simplegui.create_frame("Stopwatch Game", 300, 300)
timer = simplegui.create_timer(100, start_timer)
# Register event handlers
frame.set_draw_handler(draw)
frame.add_button("Stop", stop_button, 100)
frame.add_button("Start", start_button, 100)
frame.add_button("Reset", reset, 100)
# start frame
frame.start()
timer.start()
def draw(canvas):
global snake_coords,apple_coord, score, started
# 绘制方格，蛇和苹果
draw_grid(canvas)
draw_snake(canvas)
draw_apple(canvas)
label.set_text("得分:"+str(score))
if not started:
canvas.draw_text("游戏结束",[100, 200], 60,"blue")
# 创建frame，设置背景色
frame = simplegui.create_frame("贪吃蛇", WINDOW_WIDTH, WINDOW_HEIGHT)
frame.set_canvas_background(back_ground)
#添加按钮和label
label = frame.add_label("得分:" + str(score))
frame.add_button("难度一",click,50)
frame.add_button("难度二",click2,50)
frame.add_button("难度三",click3,50)
#添加句柄事件
frame.set_draw_handler(draw)
frame.set_keydown_handler(key_down)
#创建定时器
timer = simplegui.create_timer(200,move)
# 开始游戏
new_game()
frame.start()
Also computes the stops / winning stops
"""
global stops, wins
if (timer.is_running()):
stops += 1
if (counter % 10) == 0:
wins += 1
timer.stop()
def reset_button_handler():
""" Resets the timer, stops and winning stops
"""
global counter, wins, stops
counter = 0
wins = 0
stops = 0
# The main code of the app
frame = simplegui.create_frame("Stopwatch", 320, 240)
frame.set_draw_handler(draw_handler)
button_start = frame.add_button("Start", start_button_handler)
button_stop = frame.add_button("Stop",stop_button_handler)
button_reset = frame.add_button("Reset", reset_button_handler)
timer = simplegui.create_timer(100,tick)
frame.start()
# define event handler for timer with 0.1 sec interval
def increment():
global tenth_sec
tenth_sec += 1
# define draw handler
def draw(canvas):
global tenth_sec
global flag
canvas.draw_text(format(tenth_sec), [100, 100], 24, "White")
canvas.draw_text(game(), [150, 20], 24, "White")
# create frame
f = simplegui.create_frame("", 200, 200)
# register event handlers
timer = simplegui.create_timer(100, increment)
f.add_button("Start", start, 100)
f.add_button("Stop", stop, 100)
f.add_button("Reset", reset, 100)
f.set_draw_handler(draw)
# start frame
f.start()
# Please remember to review the grading rubric
