def click_dec():
global timer, interval
if timer.is_running():
timer.stop()
interval = interval + 200
timer = simplegui.create_timer(interval, timer_handler)
timer.start()
def auto_review():
global timer, MSG
MSG = ['', '']
if timer.is_running():
timer.stop()
else:
timer = simplegui.create_timer(timer_interval, timer_handler)
timer.start()
def auto_review():
global timer, MSG
MSG = ['','']
if timer.is_running():
timer.stop()
else:
timer = simplegui.create_timer(timer_interval, timer_handler)
timer.start()
def click_acc():
global timer, interval
if timer.is_running():
timer.stop()
# 防止变量变为0
interval = interval / 2 + 1
timer = simplegui.create_timer(interval, timer_handler)
timer.start()
def run(self):
frame = simplegui.create_frame(self.title, 200, 200, 150)
self.timer = simplegui.create_timer(100, self.timerhandler)
frame.set_draw_handler(self.drawhandler)
button_start = frame.add_button('Start', self.start, 150)
button_stop = frame.add_button('Stop', self.stop, 150)
button_clear = frame.add_button('Clear', self.clear, 150)
frame.start()
def StartGame(self) -> None:
"""Initialises the game."""
self.frame = simplegui.create_frame('Drawing', CANVAS_WIDTH,
CANVAS_HEIGHT)
self.frame.set_draw_handler(self.Draw)
self.frame.set_keydown_handler(self.KeyDown)
self.frame.set_keyup_handler(self.KeyUp)
self.timer = simplegui.create_timer(1000, self.Tick)
#self.timer.start()
self.frame.start()
def playback_sbs():
global in_play, timer, ct_history, history_draw, save_draw, timer_created, playback_rate
ct_history = -1
history_draw = []
if ((not in_play) and (0 != len(save_draw))):
in_play = True
timer = simplegui.create_timer(playback_rate, timer_handler)
timer_created = True
timer.start()
def main():
global time, color
time = 0
color = 'white'
frame = simplegui.create_frame('My Timer', 200, 200, 100)
global timer
timer = simplegui.create_timer(1, timerHandler)
frame.set_draw_handler(draw)
frame.add_button('Start', Start, 100)
frame.add_button('Stop', Stop, 100)
frame.add_button('Clear', Clear, 100)
frame.start()
def main():
global t, color
t = 0
color = 'white'
frame = simplegui.create_frame('Timer', 200, 200, 150)
# 1000 / 100 = 10, 即t自加10次为一秒
global timer
timer = simplegui.create_timer(100, timerHandler)
frame.set_draw_handler(drawHandler)
button_start = frame.add_button('Start', Start, 150)
button_stop = frame.add_button('Stop', Stop, 150)
button_clear = frame.add_button('Clear', Clear, 150)
frame.start()
def play():
# 1: process lists to temp place
global drawing_list
global pixel_list
global temp_drawing_list
global timer
global UI_protect
temp_drawing_list = drawing_list
# 2: clear list
pixel_list = []
drawing_list = []
# 3: remake list with delay
print interval
timer = simplegui.create_timer(interval, tick)
timer.start()
UI_protect = True
def play():
# 1: process lists to temp place
global drawing_list
global pixel_list
global temp_drawing_list
global timer
global UI_protect
temp_drawing_list = drawing_list
# 2: clear list
pixel_list = []
drawing_list = []
# 3: remake list with delay
print interval
timer = simplegui.create_timer(interval, tick)
timer.start()
UI_protect = True
def wait_loaded(self):
"""
Draw a progression bar on canvas
and wait until all images and sounds are fully loaded.
Then execute `self._after_function`.
After `self._max_waiting` milliseconds,
abort and execute `self._after_function`.
See details in `get_nb_sounds_loaded()` documentation.
"""
if (((self.get_nb_images_loaded() == self.get_nb_images()) and
(self.get_nb_sounds_loaded() == self.get_nb_sounds()))
or (self._max_waiting <= 0)):
self._after_function()
return
def check_if_loaded():
"""
If all images and sounds are loaded
then stop waiting and execute `self._after_function`.
"""
self.__max_waiting_remain -= Loader._interval
if (((self.get_nb_images_loaded() == self.get_nb_images()) and
(self.get_nb_sounds_loaded() == self.get_nb_sounds()))
or (self.__max_waiting_remain <= 0)):
self.__max_waiting_remain = 0
self.__timer.stop()
self._frame.set_draw_handler(lambda canvas: None)
del self.__timer
self._after_function()
self.__max_waiting_remain_started = True
self.__max_waiting_remain = self._max_waiting
if Loader.__SIMPLEGUICS2PYGAME:
from SimpleGUICS2Pygame.simpleguics2pygame import create_timer
else:
from simplegui import create_timer
self._frame.set_draw_handler(self._draw_loading)
self.__timer = create_timer(Loader._interval, check_if_loaded)
self.__timer.start()
def wait_loaded(self):
"""
Draw a progression bar on canvas
and wait until all images and sounds are fully loaded.
Then execute `self._after_function`.
After `self._max_waiting` milliseconds,
abort and execute `self._after_function`.
See details in `get_nb_sounds_loaded()` documentation.
"""
if (((self.get_nb_images_loaded() == self.get_nb_images())
and (self.get_nb_sounds_loaded() == self.get_nb_sounds()))
or (self._max_waiting <= 0)):
self._after_function()
return
def check_if_loaded():
"""
If all images and sounds are loaded
then stop waiting and execute `self._after_function`.
"""
self.__max_waiting_remain -= Loader._interval
if (((self.get_nb_images_loaded() == self.get_nb_images())
and (self.get_nb_sounds_loaded() == self.get_nb_sounds()))
or (self.__max_waiting_remain <= 0)):
self.__max_waiting_remain = 0
self.__timer.stop()
self._frame.set_draw_handler(lambda canvas: None)
del self.__timer
self._after_function()
self.__max_waiting_remain_started = True
self.__max_waiting_remain = self._max_waiting
if Loader.__SIMPLEGUICS2PYGAME:
from SimpleGUICS2Pygame.simpleguics2pygame import create_timer
else:
from simplegui import create_timer
self._frame.set_draw_handler(self._draw_loading)
self.__timer = create_timer(Loader._interval, check_if_loaded)
self.__timer.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(250, self.tick)
self._timer.start()
self._frame.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(250, self.tick)
self._timer.start()
self._frame.start()
def play():
# 1: process lists to temp place
global temp_shape_list
global temp_color_list
global temp_pos_list
global shape_list
global color_list
global pos_list
global timer
global UI_protect
temp_shape_list = shape_list
temp_color_list = color_list
temp_pos_list = pos_list
# 2: clear list
shape_list = []
color_list = []
pos_list = []
# 3: remake list with delay
print interval
timer = simplegui.create_timer(interval, tick)
timer.start()
UI_protect = True
def play():
# 1: process lists to temp place
global temp_shape_list
global temp_color_list
global temp_pos_list
global shape_list
global color_list
global pos_list
global timer
global UI_protect
temp_shape_list = shape_list
temp_color_list = color_list
temp_pos_list = pos_list
# 2: clear list
shape_list = []
color_list = []
pos_list = []
# 3: remake list with delay
print interval
timer = simplegui.create_timer(interval, tick)
timer.start()
UI_protect = True
global millis;
millis +=1;
def draw_handler(canvas):
canvas.draw_text(format_time(millis), (300,265), 150, "White");
canvas.draw_text("W/A", (770,100), 50, "Red");
canvas.draw_text("Score: "+str(wins)+"/"+str(attempts),(650,50),50,"Red");
canvas.draw_text("Stopwatch Game", (10,40), 50, "Blue");
canvas.draw_text("W--> No. of Wins", (10,360), 30, "Red");
canvas.draw_text("A--> No. of Attempts", (10,390), 30, "Red");
canvas.draw_text("m m s s ms", (300,115), 50, "Red");
canvas.draw_text("____ ____ ___", (300,115), 50, "Red");
canvas.draw_line([300, 280], [680, 280], 5, 'Green');
canvas.draw_line([300, 280], [300, 150], 5, 'Green');
canvas.draw_line([300, 150], [680, 150], 5, 'Green');
canvas.draw_line([680, 150], [680, 280], 5, 'Green');
canvas.draw_text("A--> No. of Attempts", (10,390), 30, "Red");
canvas.draw_text("*Try to stop it at 0 ms", (610,390), 30, "Pink");
frame=simplegui.create_frame("stopwatch",900,400);
frame.add_button("Start / Stop",start_timer,150);
frame.add_button(" Reset ",reset_timer,150);
timer = simplegui.create_timer(100, timer_handler);
frame.set_draw_handler(draw_handler);
frame.start();
size = splash_info.get_size()
inwidth = (center[0] - size[0] / 2) < pos[0] < (center[0] + size[0] / 2)
inheight = (center[1] - size[1] / 2) < pos[1] < (center[1] + size[1] / 2)
if (not started) and inwidth and inheight:
started = True
lives = 3
score = 0
soundtrack.play()
# 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)
rock_group = set([])
missile_group = set([])
explosion_group = set([])
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.set_mouseclick_handler(click)
timer = simplegui.create_timer(1000.0, rock_spawner)
cont_shoot_timer = simplegui.create_timer(300, my_ship.shoot)
# get things rolling
timer.start()
frame.start()
while loop:
res = conn.recv()
print res
loop = ai.process(res)
# for draw slowly
play_back()
if __name__ == '__main__':
# conn managerment
address = ('localhost', 6000)
conn = Client(address, authkey='secret password')
# UI managerment
f = simplegui.create_frame("猜数游戏 AI", 800, 600)
f.add_button("new game [0,100)", new_game, 200)
f.add_button("play back", play_back, 200)
f.add_button("ai mid", ai_mid, 200)
f.add_button("ai random", ai_random, 200)
f.set_draw_handler(draw_handler)
timer = simplegui.create_timer(200, tick)
f.start()
# conn end
timer.stop()
conn.close()
# Register event handlers
frame.add_button('Restart', restart, 200)
frame.add_label('')
button_pause = frame.add_button('Pause on', pause, 200)
frame.add_label('')
frame.add_label('')
frame.add_button('Add ball', add_ball, 200)
frame.add_label('')
frame.add_button('Quit', quit_prog)
frame.add_label('')
frame.add_label('Left player keys: W (or Z), S')
frame.add_label('Right player keys: Up, Down')
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(1000, launch_ball)
# Main
restart()
timer.start()
frame.start()
import SimpleGUICS2Pygame.simpleguics2pygame as simplegui
import random
import math
clock=0
def startGame():
print "please input a num:"
def timeClock():
global clock
print clock
clock+=1
frame=simplegui.create_frame("GuessNum",200,100)
frame.add_button("start game",startGame,100)
timer=simplegui.create_timer(1000,timeClock)
timer.start()
frame.start()
def button2_push(key):
global special_timer
global player2
if int(str(special_timer).split('.')[1]) >= 980 or int(
str(special_timer).split('.')[1]) <= 20:
player2 += 1
else:
player2 -= 1
print('player2:', player2)
def draw(canvas):
global special_timer
global player1, player2
canvas.draw_text(str(special_timer), [50, 50], 30, 'White')
canvas.draw_text(str(player1), [30, 20], 15, 'White')
canvas.draw_text(str(player2), [70, 20], 15, 'White')
frame = simplegui.create_frame('Timer', 200, 200)
#frame.add_button("player1",button1_push, 100)
#frame.add_button('player2', button2_push, 100)
frame.set_mouseclick_handler(button1_push)
frame.set_keydown_handler(button2_push)
timer = simplegui.create_timer(1, game_timer)
frame.set_draw_handler(draw)
frame.start()
timer.start()
elif count != 0:
total_stops += 1
stopped = True
timer.stop()
def Reset():
global count, success_stops, total_stops
count = 0
stop = True
total_stops = 0
success_stops = 0
timer.stop()
def tick():
global count
count += 1
frame = simplegui.create_frame("Stopwatch game", 250, 250)
frame.set_canvas_background('green')
frame.add_button("Start", Start, 100)
frame.add_button("Stop", Stop, 100)
frame.add_button("Reset", Reset, 100)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(interval, tick)
frame.start()
Reset()
# -*- coding: utf-8 -*-
from SimpleGUICS2Pygame import simpleguics2pygame as simplegui
def timer_handler1():
print "Hello boys!"
def timer_handler2():
print "Hello girls!"
timer1 = simplegui.create_timer(500, timer_handler1)
timer2 = simplegui.create_timer(1500, timer_handler2)
# timer must be started or it won't work!
timer1.start()
timer2.start()
timer.stop()
x += 1
if current_time % 10 == 0:
y += 1
label.set_text("Scores" + score(x, y))
def reset():
global current_time, x, y
current_time = 0
x = 0
y = 0
label.set_text("Scores" + score(x, y))
timer.stop()
# define event handler for timer with 0.1 sec interval
timer = simplegui.create_timer(100, increment)
# create frame
frame = simplegui.create_frame("StopWatch", 200, 200)
# register event handlers
label = frame.add_label("Scores" + score(x, y))
frame.add_button("Start", start)
frame.add_button("Stop", stop)
frame.add_button("Reset", reset)
frame.set_draw_handler(draw)
# start timer and frame
frame.start()
# remember to review the grading rubric
# create frame
frame = simplegui.create_frame("Mouse selection", width, height)
frame.set_canvas_background("White")
frame.add_button("Circle\n", click_circle, 100)
frame.add_button("Triangle\n", click_triangle, 100)
frame.add_button("Square\n", click_square, 100)
frame.add_label("", 100)
frame.add_button("Red\n", click_red, 100)
frame.add_button("Blue\n", click_blue, 100)
frame.add_button("Green\n", click_green, 100)
frame.add_label("", 100)
frame.add_button("Play\n", click_review, 80)
frame.add_button("Accelarate\n", click_acc, 80)
frame.add_button("Decel\n", click_dec, 80)
frame.add_button("Stop\n", click_stop, 80)
frame.add_label("", 100)
frame.add_button("Save\n", click_output, 80)
timer = simplegui.create_timer(interval, timer_handler)
# register event handler
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
# start frame
frame.start()
elif not inrangetop1:
paddle1_pos+=10
else:
paddle1_pos-=10
if inrangetop2 and inrangebot2:
paddle2_pos+=paddle2_vel
elif not inrangetop2:
paddle2_pos+=10
else:
paddle2_pos-=10
if ball_vel[0]>0:
ball_vel[0]+=0.002
else:
ball_vel[0]-=0.002
# create frame
frame = simplegui.create_frame("Pong", WIDTH, HEIGHT)
frame.set_canvas_background("blue")
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.add_button("Restart game",restart,100)
frame.add_label("CONTROLS: PLAYER1 : w s \nPLAYER2: up down")
timer=simplegui.create_timer(1,tick)
timer.start()
# start frame
new_game()
frame.start()
def format():
global mil
global sec
global minute
global final
mil = str(mil)
sec = str(sec)
minute = str(minute)
final = minute + ":" + sec + "." + mil
return final
def draw(canvas):
canvas.draw_text(final, (250, 250), 50, "green")
canvas.draw_text(game_print, (350, 50), 20, "red")
frame = simplegui.create_frame("Stopwatch Game", 500, 500)
timer = simplegui.create_timer(timer_val, increment)
frame.set_canvas_background("cyan")
frame.add_button("Start", start)
frame.add_button("Stop", stop)
frame.add_button("Reset", reset)
frame.set_draw_handler(draw)
timer.start()
frame.start()
# -*- coding: utf-8 -*-
from SimpleGUICS2Pygame import simpleguics2pygame as simplegui
def timer_handler1():
print "Hello boys!"
def timer_handler2():
print "Hello girls!"
timer1 = simplegui.create_timer(500, timer_handler1)
timer2 = simplegui.create_timer(1500, timer_handler2)
# timer must be started or it won't work!
timer1.start()
timer2.start()
#try:
# import simplegui
#except ImportError:
# import SimpleGUICS2Pygame.simpleguics2pygame as simplegui
from SimpleGUICS2Pygame import simpleguics2pygame
name = "Welcome"
counter = 0
def greet():
global name
global counter
counter = counter + 1
def tick():
greet()
print(counter)
print("Welcome " + name)
def buttonpress():
global name
name = "man"
frame = simpleguics2pygame.create_frame("Hello", 100, 100)
timer = simpleguics2pygame.create_timer(500, tick)
frame.add_button("Click me!", buttonpress)
frame.start()
timer.start()
rock_vel = [
random.random() * ROCK_VELOCITY - ROCK_VELOCITY / 2,
random.random() * ROCK_VELOCITY - ROCK_VELOCITY / 2
]
rock_avel = random.random() * .2 - .1
a_rock = Sprite(rock_pos, rock_vel, 0, rock_avel, asteroid_image,
asteroid_info)
if not a_rock.collide(my_ship):
rock_group.add(a_rock)
rock_counter += 1
# initialize stuff
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)
# 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)
timer_shoot = simplegui.create_timer(50, my_ship.shoot)
# get things rolling
timer.start()
frame.start()
my_ship.shoot()
def keyup(key):
if key == simplegui.KEY_MAP['up']:
my_ship.thrust = False
if key == simplegui.KEY_MAP['left'] or key == simplegui.KEY_MAP['right']:
my_ship.angle_vel = 0
# 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], [0, 0], 0, 1, asteroid_image,
asteroid_info)
a_missile = Sprite([-1, -1], [0, 0], 0, 0, missile_image, missile_info,
missile_sound)
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
timer = simplegui.create_timer(1000.0, rock_spawner)
# get things rolling
timer.start()
frame.start()
vy=-1
elif key==simplegui.KEY_MAP['right']:
vx=1
elif key==simplegui.KEY_MAP['down']:
vy=1
def stop(key):
global vx, vy
if key==simplegui.KEY_MAP['down']:
vy=0
elif key==simplegui.KEY_MAP['up']:
vy=0
elif key==simplegui.KEY_MAP['left']:
vx=0
elif key==simplegui.KEY_MAP['right']:
vx=0
def update():
pos[0]=(pos[0]+vx)%500
pos[1]=(pos[1]+vy)%500
frame=simplegui.create_frame("frame",500,500)
timer=simplegui.create_timer(10,update)
frame.set_draw_handler(drawball)
frame.set_keydown_handler(move)
frame.set_keyup_handler(stop)
frame.start()
rock_pos = [random.randrange(0, WIDTH), random.randrange(0, HEIGHT)]
# ensure rock_pos is at least 100px away of my_ship
while dist(rock_pos, my_ship.pos) < 100:
rock_pos = [random.randrange(0, WIDTH), random.randrange(0, HEIGHT)]
# add rock to the group
rock_group.add(Sprite(rock_pos, rock_vel, 0, rock_avel,
asteroid_image, asteroid_info))
# initialize stuff
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)
rock_group = set()
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()
canvas.draw_text(format_time(time), [90, 120], 50, "White", "sans-serif")
canvas.draw_text(format_score(score), [220, 40], 24, "Green", "sans-serif")
canvas.draw_text("by VG", [270, 190], 8, "Gray", "monospace")
# create frame
frame = simplegui.create_frame("Stopwatch Game", 300, 200)
# create buttons with event handlers
frame.add_button("Start", start, 100)
frame.add_button("Stop", stop, 100)
frame.add_button("Reset", reset, 100)
# create timer
timer = simplegui.create_timer(interval, tick)
# set the draw handler for canvas
frame.set_draw_handler(draw)
# start frame and the game. HAVE FUN! :)
frame.start()
shield_cool_down_timer.stop()
# initialize stuff
frame = simplegui.create_frame("Space Glory", WIDTH, HEIGHT)
# initialize ship and two sprites
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
rock_group = set()
boss_group = set()
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)
cooling_timer = simplegui.create_timer(500.0, cool_down)
overheat_timer = simplegui.create_timer(3000.0, engine_burned)
cooling_down_in = simplegui.create_timer(1000.0, repair_engine)
shield_cool_down_timer = simplegui.create_timer(10000.0, recharge_shield)
cooling_timer.start()
# get things rolling
timer.start()
frame.start()
if current_time % 10 == 0:
y += 1
label.set_text("Scores" + score(x, y))
def reset():
global current_time, x, y
current_time = 0
x = 0
y = 0
label.set_text("Scores" + score(x, y))
timer.stop()
# define event handler for timer with 0.1 sec interval
timer = simplegui.create_timer(100, increment)
# create frame
frame = simplegui.create_frame("StopWatch", 200, 200)
# register event handlers
label = frame.add_label("Scores" + score(x, y))
frame.add_button("Start", start)
frame.add_button("Stop", stop)
frame.add_button("Reset", reset)
frame.set_draw_handler(draw)
# start timer and frame
frame.start()
# remember to review the grading rubric
inwidth = (center[0] - size[0] / 2) < pos[0] < (center[0] + size[0] / 2)
inheight = (center[1] - size[1] / 2) < pos[1] < (center[1] + size[1] / 2)
if (not started) and inwidth and inheight:
started = True
lives = 3
score = 0
soundtrack.play()
# 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)
rock_group = set([])
missile_group = set([])
explosion_group = set([])
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.set_mouseclick_handler(click)
timer = simplegui.create_timer(1000.0, rock_spawner)
cont_shoot_timer = simplegui.create_timer(300, my_ship.shoot)
# get things rolling
timer.start()
frame.start()
#try:
# import simplegui
#except ImportError:
# import SimpleGUICS2Pygame.simpleguics2pygame as simplegui
from SimpleGUICS2Pygame import simpleguics2pygame
name = "Welcome"
counter = 0
def greet():
global name
global counter
counter = counter + 1
def tick():
greet()
print(counter)
print("Welcome " + name)
def buttonpress():
global name
name = "man"
frame = simpleguics2pygame.create_frame("Hello", 100, 100)
timer = simpleguics2pygame.create_timer(500, tick)
frame.add_button("Click me!", buttonpress)
frame.start()
timer.start()
frame.add_button("Play", play)
frame.add_button("Stop", stop)
frame.add_button("Reset", reset)
frame.set_draw_handler(draw_all)
print(action_consequence_estimates)
frame.add_label("\n\n\n")
frame.add_label("\n\n\n")
frame.add_label(
"\n\nProbability Distribution known by the agent for action left : \n\n")
frame.add_label("\n\n\n")
label1 = frame.add_label('P_left_goes-left = %.3f' %
(action_consequence_estimates[0][0] /
action_consequence_estimates[0]["ntimes"]))
label2 = frame.add_label('P_left_goes-up = %.3f' %
(action_consequence_estimates[0][2] /
action_consequence_estimates[0]["ntimes"]))
label3 = frame.add_label('P_left_goes-down = %.3f' %
(action_consequence_estimates[0][3] /
action_consequence_estimates[0]["ntimes"]))
frame.add_label("\n\n\n")
frame.add_label("\n\n\n")
frame.add_button("Board1", set_board1)
frame.add_button("Board2", set_board2)
timer_play = simplegui.create_timer(500, one_step)
timer_singlerun = simplegui.create_timer(500, one_step)
# Start the frame animation
frame.start()
for s in pp[0]:
print s
p4shape.append("%s_%s" % (s[0], s[1]))
print p4shape
_encode = "%s-%s-%s-%s-%s" % ("-".join(p4shape), pp[1], pp[2], pp[3],
pp[4])
_exp.append(_encode)
print _encode
#print "+".join(_exp)
put_points = "+".join(_exp)
print put_points
_SAE = 'http://zoomquiet.sinaapp.com/api/echo'
echo_txt = urllib2.urlopen('%s/%s' % (_SAE, put_points))
_uri = echo_txt.read()
print _uri
inp_dump_sae.set_text(_uri)
frame.add_button('dump painting', btn_dump, 100)
# http://zoomquiet-ppreload.stor.sinaapp.com/15040214283617515_pp.log
inp_dump_sae = frame.add_input('reload URI', load_pp4sae, 150)
frame.set_draw_handler(draw_all)
frame.set_mouseclick_handler(click_point)
frame.set_canvas_background('White')
timer = simplegui.create_timer(timer_interval, timer_handler)
frame.start()
RestartGame = frame.add_button("Restart", button_Restart)
empty_label = frame.add_label('')
frame.set_draw_handler(canvas_Menu)
read_highscores() #Initially reads the highscore file
global wall_check
wall_check = 0
Walls_State = frame.add_button("Walls: Enabled",
button_walls) #Walls enabled initially
empty_label = frame.add_label('')
HighScore = frame.add_button("Highscores", button_HighScoreScreen)
empty_label = frame.add_label('')
reset_highscores = frame.add_button("Reset highscores",
button_reset_highscores)
empty_label = frame.add_label('')
Quit = frame.add_button("Quit", button_quit)
empty_label = frame.add_label('')
score_display = frame.add_label("Score: -")
frame.set_draw_handler(canvas_Menu)
timer = sg.create_timer(timer_interval, timer_handler)
timer.start()
frame.start()
__author__ = 'mdmytiaha'
# Example of a simple event-driven program
# CodeSkulptor GUI module
import SimpleGUICS2Pygame.simpleguics2pygame as simplegui
# Event handler
def tick():
print "tick!"
# Register handler
timer = simplegui.create_timer(1000, tick)
# Start timer
timer.start()
attempts = 0
hits = 0
ticking = True
# define event handler for timer with 0.1 sec interval
def tenths_second():
global tenths
tenths += 1
# define draw handler
def draw_current_time(canvas):
canvas.draw_text(str(attempts) + "/" + str(hits), [250, 30], 20, "Red")
if tenths <= 6000:
canvas.draw_text(format(tenths), [125, 110], 20, "White")
else:
canvas.draw_text("The time is up!", [125, 110], 20, "White")
# create frame
frame = simplegui.create_frame("Stopwatch", 300, 200)
Button1 = frame.add_button("Start", start, 50)
Button2 = frame.add_button("Stop", stop, 50)
Button3 = frame.add_button("Reset", reset, 50)
# register event handlers
timer = simplegui.create_timer(100, tenths_second)
frame.set_draw_handler(draw_current_time)
# start frame
frame.start()
flag = True
timer_time = 0
def timer_count():
global timer_time
timer_time += 0.001
def button_start():
global flag
flag = False
global timer_time
timer_time = 0
def button_finish():
global flag
flag = True
global timer_time
print(timer_time)
frame = simplegui.create_frame('Timer', 100, 100)
frame.add_button("start", button_start, 100)
frame.add_button('finish', button_finish, 100)
timer = simplegui.create_timer(1, timer_count)
frame.start()
timer.start()
# define event handler for timer with 0.1 sec interval
def on_time_handler():
global time_message, counter
counter += 100
time_message = format(counter)
# define draw handler
def on_draw_timer(canvas):
canvas.draw_text(time_message, (60, 100), 30, 'Red')
canvas.draw_text(str(success) + "/" + str(attempts), (140, 20), 30, 'Green')
# create frame
frame = simplegui.create_frame("StopWatch", 200, 200)
timer = simplegui.create_timer(100, on_time_handler)
# register event handlers
frame.set_draw_handler(on_draw_timer)
button_start = frame.add_button("Start", on_start, 100)
button_stop = frame.add_button("Stop", on_stop, 100)
button_reset = frame.add_button("Reset", on_reset, 100)
# start frame
frame.start()
# Please remember to review the grading rubric
'''Displays watch, scores and instructions'''
# watch
format(time_val)
canvas.draw_text(time_formated, [75, 120], 40, "White")
# scores
your_score = 'Your score: ' + str(score) + ' Tries: ' + str(attempt)
canvas.draw_text(your_score, [15, 30], 20, "Yellow")
# instructions
instructions = 'Try to Stop on even seconds to get point.'
canvas.draw_text(instructions, [5, 195], 12, "Aqua")
# create frame
frame = simplegui.create_frame("Stopwatch Game", 300, 200)
frame.set_canvas_background("Green")
# register event handlers
frame.set_draw_handler(display)
timer = simplegui.create_timer(100, stoper)
button_start = frame.add_button('Start', start, 100)
button_stop = frame.add_button('Stop', stop, 100)
button_reset = frame.add_button('Reset', reset, 100)
# start timer and frame
frame.start()
# seems working!
all_stops = 0
win_stops = 0
timer.stop()
def teak():
global mlsec
mlsec += 1
def draw(canvas):
text = view_timer(mlsec)
canvas.draw_text(text, (100, 150), 50, "white")
canvas.draw_text(
str(win_stops) + "/" + str(all_stops), (250, 35), 30, "yellow")
f = simplegui.create_frame("Stop: game", 300, 300)
f.set_canvas_background("blue")
f.add_button("start", start, 100)
f.add_button("stop", stop, 100)
f.add_button("reset", reset, 100)
f.set_draw_handler(draw)
timer = simplegui.create_timer(gap, teak)
f.start()
reset()
