def __init__(self):
self.tetris = {}
self.pile = Pile()
self.time = 0
self.state = 0
self.score = 0
self.chain = 0
self.points = []
self.move_dict = {}
self.best = 0
self.time1 = simplegui.create_timer(500, self.tetri_down)
self.time2 = simplegui.create_timer( 20, self.tetri_down)
self.time3 = simplegui.create_timer(120, self.pile_update)
self.timer = simplegui.create_timer(1000, self.count_down)
self.frame = simplegui.create_frame('Tetris', width, height)
def reset_handler():
global timer, t, attempts, score
timer.stop()
t = 0
attempts = 0
score = 0
timer = simplegui.create_timer(interval, timer_handler)
def __init__(self):
"""
Set elements of the game.
"""
self.loaded = False
self.keydown_left = False
self.keydown_right = False
self.lives = 3
self.my_ship = None
self.nb_bombs = None
self.score = 0
self.started = False
self.time = 0
self.explosions = []
self.live_explosions = []
self.missiles = []
self.rocks = []
self.animate_background_active = True
self.music_active = True
self.sounds_active = True
self.timer = simplegui.create_timer(1000, self.rock_spawner)
self.img_infos = None
self.medias = None
def __init__(self,center_xy = (30,200),radius = 10 ,motion_vector=(1.0,0.5)):
self.xy = center_xy
self.radius = radius
self.radius_squared = radius * radius
self.color = "orange"
self.tics = 0
self.last_move_1_or_more = (0,0)
self.mv = motion_vector # px/s x , px/s y
self.timer_interval = 20.0
self.tic_freq = self.timer_interval / 1000.0
self.d_per_tic = (self.tic_freq * self.mv[0],self.tic_freq * self.mv[1])
if self.d_per_tic[0] == 0.0:
move_freq_x = 999999
else:
move_freq_x = abs(1.0 / self.d_per_tic[0])
if self.d_per_tic[1] == 0.0:
move_freq_y = 999999
else:
move_freq_y = abs(1.0 / self.d_per_tic[1])
self.move_freq = (move_freq_x,move_freq_y)
self.timer = simplegui.create_timer(int(self.timer_interval),self.tic)
self.timer.start()
self.last_hit = -1
self.walls = []
def gameWindow_init():
global pong_frame, reset_timer
# Create Game Window
pong_frame = simplegui.create_frame("Pong", roomRect.getWidth(), roomRect.getHeight(), 300)
game_instructions = []
game_instructions.append(pong_frame.add_label("Welcome to Pong!"))
game_instructions.append(pong_frame.add_label(""))
game_instructions.append(pong_frame.add_label("Up and Down arrow keys control the Blue paddle"))
game_instructions.append(pong_frame.add_label(""))
game_instructions.append(pong_frame.add_label("W and S keys control the Red paddle"))
game_instructions.append(pong_frame.add_label(""))
game_instructions.append(pong_frame.add_label("Click anywhere in the game window to start"))
game_instructions.append(pong_frame.add_label(""))
game_instructions.append(pong_frame.add_label("May the force be with you."))
game_instructions.append(pong_frame.add_label(""))
# Game Window Buttons and Controls
# resetButton = pong_frame.add_button("New Game", new_game, 150)
pong_frame.add_button("Single Player (vs Computer)", singlePlayer, 250)
pong_frame.add_button("2 Player (Restart)", twoPlayer, 250)
# Timers
reset_timer = simplegui.create_timer(1000, reset_pause)
# Register event handlers
pong_frame.set_keydown_handler(keydown)
pong_frame.set_keyup_handler(keyup)
pong_frame.set_draw_handler(draw)
pong_frame.set_mouseclick_handler(mouseclick_startGame)
def rock_spawner():
global rock_group
if started:
if len(rock_group) < 12:
rock_pos = [random.randrange(0, WIDTH), random.randrange(0, HEIGHT)]
rock_vel = [random.random() * ROCK_VEL_FACTOR - ROCK_VEL_FACTOR / 2, random.random() * ROCK_VEL_FACTOR - ROCK_VEL_FACTOR / 2]
rock_avel = random.random() * ROCK_AVEL_FACTOR - ROCK_AVEL_FACTOR / 2
a_rock = Sprite(rock_pos, rock_vel, 0, rock_avel, asteroid_image, asteroid_info)
# add rock to group only if its not colliding with the ship
if not a_rock.collide(my_ship):
rock_group.add(a_rock)
# Main part
# Declare 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([])
explosions_group = set([])
missiles_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 __init__(self,interval):
self.interval = interval
self.timer = simplegui.create_timer(interval, self.tic)
self.step = 1
self.tic_signal = Signal("tic")
SignalSender.__init__(self)
print('TimerManager __init__ done')
def deal():
global outcome, in_play, deck, dealer, player
global timer, status, dealed, score
if in_play:
in_play = False
dealed = True
status = LOOSE
timer = simplegui.create_timer(2000, timer_handler)
timer.start()
score -= 1
else:
in_play = True
dealed = False
# your code goes here
deck = Deck()
dealer = Hand()
player = Hand()
deck.shuffle()
i=0
while i<2:
player.add_card(deck.deal_card())
dealer.add_card(deck.deal_card())
i+=1
#print "Player " + str(player)
#print "Dealer " + str(dealer)
outcome = "Hit or Stand?"
def setup_frame():
# initialize stuff
global timer, quiz, questions
quiz = Quiz(questions)
frame = simplegui.create_frame("QUIZ", WIDTH, HEIGHT)
timer = simplegui.create_timer(1000, timer_handler)
frame.set_canvas_background("Pink")
# register handlers
#frame.set_keyup_handler(keyup)
#frame.set_keydown_handler(keydown)
#frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
frame.add_label("Game Controls")
frame.add_button("Restart", restart, 100)
frame.add_button("Next Question", nextQuestion, 100)
frame.add_button("Review Question", prev, 100)
# frame.add_button("Reset Question", resetQuestion, 100)
frame.add_label("Select Your Answer")
frame.add_button("A", selectA, 100)
frame.add_button("B", selectB, 100)
frame.add_button("C", selectC, 100)
frame.add_button("D", selectD, 100)
# get things rolling
init_game()
frame.start()
def init():
# initialize frame
global my_ship, a_missile, frame, timer, upgrade_number, upgrade_dist
frame = simplegui.create_frame("Asteroids, by dare7", WIDTH, HEIGHT)
upgrade_number = frame.add_button("+1 missile for %s$" % str(upgrade_cost), upgrade_count, 180)
upgrade_dist = frame.add_button("+1 missile range %s$" % str(upgrade_cost), upgrade_range, 180)
frame.add_button("Reset all", full_reset, 180)
frame.add_button("Quit", quit, 180)
# 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_keydown_handler(key_down)
frame.set_keyup_handler(key_up)
frame.set_mouseclick_handler(click)
frame.add_label("Shoot stars!")
frame.add_label("Earn money!")
frame.add_label("Avoid collision!")
frame.add_label("Upgrade ship!")
frame.add_label("")
frame.add_label("Controls:")
frame.add_label("Up: accelerate")
frame.add_label("Left, right: turn")
frame.add_label("Space: shoot")
timer = simplegui.create_timer(1000.0, rock_spawner)
# get things rolling
timer.start()
frame.start()
def __init__(self, delay):
# sets the initial time to 0
self.time = 0
# sets the delay
self.delay = delay
# creates a timer
self.timer = simplegui.create_timer(delay, self.count)
def start(self):
self.img_loader.start()
frame = simplegui.create_frame(
self.title,
self.width,
self.height
)
frame.set_draw_handler(self.draw_handler)
frame.set_mouseclick_handler(self.mouse_click_handler)
frame.set_canvas_background("#87CEEB")
frame.start()
self.init_balls()
self.init_clouds(2)
self.cloud_timer = simplegui.create_timer(
10 * 1000,
self.add_cloud)
self.cloud_timer.start()
frame.add_button("Clear sky", self.clear_clouds)
# frame.add_button("Add cloud", self.add_cloud)
self.rs_button = frame.add_button("Enable radius shrink", self.toggle_radius_shrink)
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 start(self):
"""
Start calculation and drawing.
See `draw_fct()`.
"""
if self._timer is not None:
self.stop()
self._fps = 0
self._nb_frames_drawed = 0
self._nb_seconds = 0
try:
from simplegui import create_timer
except ImportError:
from SimpleGUICS2Pygame.simpleguics2pygame import create_timer
def update():
"""
Update counters.
"""
if self._timer is not None:
self._nb_seconds += 1
self._fps = int(round(float(self._nb_frames_drawed)
/ self._nb_seconds))
self._timer = create_timer(1000, update)
self._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 reset():
global t, curr_time, x, y, running
x = 0
y = 0
running = False
t.stop()
t = simplegui.create_timer(100, tick)
curr_time = 0
def timer_handler():
global Count, timer
Count += 1
print Count
if Count == 10:
timer.stop()
timer = simplegui.create_timer(1000, timer_handler)
timer.start()
def __init__(self, images, finished_callback=None, check_interval=250):
self.images = images
self.images_len = len(images)
self.timer = simplegui.create_timer(check_interval, self._timer_handler)
self.finished_callback = finished_callback
self.total_count = len(images)
self.loaded_count = 0
self.progress = 0
def handle_timer():
global gbl_timer
global gbl_timer_is_runing
bool( gbl_timer_is_runing )
if gbl_timer_is_runing == False:
if gbl_timer == None:
gbl_timer = simplegui.create_timer( gbl_timer_interval, handle_timer_event)
gbl_timer.start()
gbl_timer_is_runing = 1
def auto_review():
global timer
#点击自动回放开关
if timer.is_running():
timer.stop()
else:
timer = simplegui.create_timer(interval,timer_handler)
timer.start()
pass
def spawn_ball():
global ball_pos, ball_v, direction
def faqiu():
global ball_v
ball_v= [random.randrange(2,4)*direction, random.randrange(1, 3)*random.choice([1,-1])]
timer.stop()
ball_pos = [WIDTH/2,HEIGHT/2]
ball_v= [0,0]
timer = simplegui.create_timer(1000, faqiu)
timer.start()
def reset_button_handler():
global a, bc, d, Stop
a = 0
bc = 0
d = 0
t="0000"
timer = simplegui.create_timer(100, timer_handler)
if Stop:
Stop=False
timer.start()
def reset():
global timer, time, sec, min, mil, count, asserts
timer.stop()
timer = simplegui.create_timer(100,time_handler)
time = 0
min = 0
sec = 0
mil = 0
count = 0
asserts = 0
def go():
with open('floorplan.txt','r') as f:
for line in f:
args = line.strip().split(',')
if args[0] == 'width':
globals.board_size[0] = int(args[1])
elif args[0] == 'height':
globals.board_size[1] = int(args[1])
elif args[0] == 'bay':
globals.bays.add(classes.bay(int(args[1]), int(args[2])))
elif args[0] == 'barrier':
globals.barriers.add(classes.barrier(int(args[1]), int(args[2])))
elif args[0] == 'dropoff_point':
globals.dropoff_points.add(classes.dropoff_point(int(args[1]), int(args[2])))
elif args[0] == 'tote':
globals.totes.append(classes.tote(int(args[1]), int(args[2]), random.randint(1,10)))
globals.frame = simplegui.create_frame('Warehouse Man', globals.grid_size * globals.board_size[0], globals.grid_size * globals.board_size[1])
globals.frame.set_canvas_background('white')
globals.frame.set_draw_handler(e.draw_handler)
globals.frame.set_keydown_handler(e.keydown_handler)
globals.frame.set_keyup_handler(e.keyup_handler)
cadence = simplegui.create_timer(100, e.poll_keyboard)
globals.timers.add(cadence)
tote_generator_timer = simplegui.create_timer(60/globals.totes_per_minute * 1000, e.generate_tote)
globals.timers.add(tote_generator_timer)
cleanup_timer = simplegui.create_timer(1000, helpers.clean_up_totes)
globals.timers.add(cleanup_timer)
order_create_timer = simplegui.create_timer(60/globals.orders_per_minute * 1000, helpers.place_order)
globals.timers.add(order_create_timer)
order_countdown_timer = simplegui.create_timer(1000, e.age_orders)
globals.timers.add(order_countdown_timer)
globals.packer = classes.player('Packer', 13, 8, 'blue')
globals.picker = classes.player('Picker', 2, 8, 'cyan')
globals.active_player = globals.packer
globals.inactive_player = globals.picker
e.generate_tote()
helpers.start_timers()
globals.frame.start()
def run_game(self):
frame = simplegui.create_frame('Asteroids', WIDTH, HEIGHT)
frame.set_draw_handler(self.draw)
frame.set_keydown_handler(self.keydown)
frame.set_keyup_handler(self.keyup)
time_interval = 1000.0
timer = simplegui.create_timer(time_interval, self.rock_spawner)
frame.set_mouseclick_handler(self.click)
timer.start()
frame.start()
def main():
# initialize stuff
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
# register handlers
frame.set_keyup_handler(keyup)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
timer1 = simplegui.create_timer(1000.0, rock_spawner)
timer2 = simplegui.create_timer(1000.0, ship_spawner)
# get things rolling
timer1.start()
timer2.start()
frame.start()
# start game
new_game()
def reset():
global timer
global tick
global is_stop
global attempt
global success
tick = 0
timer.stop()
attempt = 0
success = 0
is_stop = True
timer = simplegui.create_timer(100, timer_handler)
def set_unload_handler(frame, handler, period = 1000):
def unload_check():
#credit: Michael Cimino for set_unload_handler
try:
textwidth = frame.get_canvas_textwidth("t",12)
except:
textwidth = 0
if textwidth==0:
unloaded_check_timer.stop()
handler()
unloaded_check_timer = simplegui.create_timer(period, unload_check)
unloaded_check_timer.start()
def keydown_handler(key):
global angle_accel, angle_accel_timer, thrusting, is_pressing_left, is_pressing_right
angle_accel_val = 0.008
if key == simplegui.KEY_MAP['left']:
angle_accel = -angle_accel_val
if angle_accel_timer:
angle_accel_timer.stop()
angle_accel_timer = simplegui.create_timer( ( 1000 / 60), spin_ship)
my_ship.angle_vel = 0
angle_accel_timer.start()
is_pressing_left = True
elif key == simplegui.KEY_MAP['right']:
angle_accel = angle_accel_val
if angle_accel_timer:
angle_accel_timer.stop()
angle_accel_timer = simplegui.create_timer( ( 1000 / 60), spin_ship)
my_ship.angle_vel = 0
angle_accel_timer.start()
is_pressing_right = True
elif key == simplegui.KEY_MAP['up']:
my_ship.set_thrust(True)
elif key == simplegui.KEY_MAP['space']:
my_ship.shoot()
def start():
"""
Start the game.
"""
global timer
if SIMPLEGUICS2PYGAME:
frame._set_canvas_background_image(loader.get_image('nebula'))
frame.set_draw_handler(draw)
timer = simplegui.create_timer(1000, rock_spawner)
timer.start()
rock_spawner()
# determine if the group of missiles collide with the group of rocks
# return the number of collisions, so we can increment the score
def group_group_collide(group,other_group):
remove_set = set()
for element in group:
if (group_collide(other_group,element)):
remove_set.add(element)
group.difference_update(remove_set)
return (len(remove_set))
# 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)
#a_rock = Sprite([WIDTH / 3, HEIGHT / 3], [1, 1], 0, .1, 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_keyup_handler(keyup)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(ROCK_SPAWN_TIME, rock_spawner)
# get things rolling
timer.start()
frame.start()
rock_vel[1] += 10 * rock_vel[1]
elif score > 300:
rock_vel[0] += 20 * rock_vel[0]
rock_vel[1] += 20 * rock_vel[1]
rock_avel = random.random() * .2 - .1
a_rock = Sprite(rock_pos, rock_vel, 0, rock_avel, asteroid_image,
asteroid_info)
if dist(rock_pos, my_ship.pos) > 2 * my_ship.radius:
rock_group.add(a_rock)
# 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([])
# 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()
reset()
def keyup_handler(key):
my_ship.thrust = False
my_ship.rot = 0
my_ship.missile = False
ship_thrust_sound.rewind()
#missile_sound.rewind()
# initialize frame
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
# initialize ship and two sprites
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, 0.03, ship_image, ship_info,
flame_info)
## my_ship=Ship(initial position, initial velocity, initial angle, fricition, ship image, no flame info, flame 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_keydown_handler(keydown_handler)
frame.set_keyup_handler(keyup_handler)
timer = simplegui.create_timer(interval, rock_spawner)
# get things rolling
timer.start()
frame.start()
canvas.draw_circle([WIDTH / 2, HEIGHT / 2], radius**1.5, 5, "yellow")
canvas.draw_circle([WIDTH / 2, HEIGHT / 2], radius**1.2, 1, "white")
canvas.draw_circle([WIDTH / 3, HEIGHT / 2], radius, 2, "red")
canvas.draw_circle([WIDTH / 3, HEIGHT / 2], radius**2, 2, "blue")
canvas.draw_circle([WIDTH / 3, HEIGHT / 2], radius**1.75, 3, "pink")
canvas.draw_circle([WIDTH / 3, HEIGHT / 2], radius**0.5, 8, "green")
canvas.draw_circle([WIDTH / 3, HEIGHT / 2], radius**1.5, 4, "yellow")
canvas.draw_circle([WIDTH / 3, HEIGHT / 2], radius**1.2, 1.5, "white")
canvas.draw_circle([WIDTH / 1.5, HEIGHT / 2], radius, 1, "red")
canvas.draw_circle([WIDTH / 1.5, HEIGHT / 2], radius**2, 2, "blue")
canvas.draw_circle([WIDTH / 1.5, HEIGHT / 2], radius**1.75, 3, "pink")
canvas.draw_circle([WIDTH / 1.5, HEIGHT / 2], radius**0.5, 8, "green")
canvas.draw_circle([WIDTH / 1.5, HEIGHT / 2], radius**1.5, 5, "yellow")
canvas.draw_circle([WIDTH / 1.5, HEIGHT / 2], radius**1.2, 2, "white")
canvas.draw_circle([WIDTH / 2, HEIGHT / 2], radius**1.4, 3, "orange")
# Create frame and timer
f = simplegui.create_frame("Radius", WIDTH, HEIGHT, 60)
t = simplegui.create_timer(100, tradius)
f.set_draw_handler(draw)
# Start timer
f.start()
t.start()
def background_timer_handler():
global Color_Counter_Background_Background
global Current_Color_Background
global Counter_Background
global Color_Rainbow
if Rainbow_Toggle == True:
if Color_Counter_Background_Background < 6:
Color_Counter_Background_Background = Color_Counter_Background_Background + 1
else:
Color_Counter_Background_Background = 0
Current_Color_Background = Color_Rainbow[
Color_Counter_Background_Background]
frame.set_canvas_background(Current_Color_Background)
timer = simplegui.create_timer(background_timer_interval,
background_timer_handler)
timer.start()
background_timer_handler()
def time_text_handler():
global Color_Counter_Text
global Current_Color_Text
global Counter_Background
global Color_Rainbow
global Current_Color_Text
global Color_Counter_Text
if Rainbow_Toggle == True:
if Color_Counter_Text < 6:
Color_Counter_Text = Color_Counter_Text + 1
else:
else:
paddle_northwest_point = frame_size[1] - paddle_height
else:
pass
def ball_tick():
"""define ball movement based on timer"""
global ball_pos, ball_time, ball_shift_size
ball_time += 1
if ball_time % 100 == 0:
ball_shift_size += 5
ball_pos = add_vector(ball_pos,
multiply_vector(ball_vector, ball_shift_size))
ball_collision()
ball_reflection()
# define frame
frame = simplegui.create_frame("Pong", frame_size[0], frame_size[1])
paddle_timer = simplegui.create_timer(100, paddle_tick)
ball_timer = simplegui.create_timer(200, ball_tick)
# register handler functions
frame.set_draw_handler(draw)
frame.set_keydown_handler(paddle_shift)
frame.set_keyup_handler(stop_paddle_shift)
# start frame
frame.start()
ball_timer.start()
def func_reset():
timer.stop()
global t, s1, s2, m, p, x, y, z
t = 0
s1 = 0
s2 = 0
m = 0
p = str(m) + ":" + str(s1) + str(s2) + "." + str(t)
x = 0
y = 0
z = str(y) + "/" + str(x)
# define event handler for timer with 0.1 sec interval
timer = simplegui.create_timer(100, format)
# define draw handler
def draw_sthing(canvas):
global p, z
canvas.draw_text(str(p), [100, 100], 50, "White")
canvas.draw_text(str(z), [200, 30], 40, "Green")
# create frame
frame = simplegui.create_frame("Stopwatch", 300, 200)
# register event handlers
def start():
# Start the frame animation
frame.start()
timer = simplegui.create_timer(250, actualize)
frame.set_keydown_handler(keyDown)
timer.start()
flag = 1
def stop():
global flag, attempts, score
flag = 0
if (second % 5 == 0):
attempts += 1
score += 1
else:
attempts += 1
def reset():
global flag, val, minute, second, tempSec, milisec
val = "0.00.0"
flag = 0
minute = second = milisec = 0
tempSec = "00"
frame = simplegui.create_frame("StopWatch", 300, 300)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(100, convert)
frame.add_button("Start", start, 50)
frame.add_button("Stop", stop, 50)
frame.add_button("Reset", reset, 50)
frame.start()
timer.start()
or (max_test_images_loaded <= 0)):
timer.stop()
frame.set_draw_handler(draw)
max_test_images_loaded -= 1
# Main
if __name__ == '__main__':
# Create frame
frame = simplegui.create_frame('Blackjack', FRAME_WIDTH, FRAME_HEIGHT, 100)
# Control panel
frame.add_button('Deal', deal, 100)
frame.add_label('')
frame.add_button('Hit', hit, 100)
frame.add_label('')
frame.add_button('Stand', stand, 100)
frame.add_label('')
frame.add_label('')
frame.add_button('Quit', frame.stop)
# Register event handlers
frame.set_draw_handler(draw_wait_images)
timer = simplegui.create_timer(100, test_images_loaded)
timer.start()
test_images_loaded()
frame.start()
def timer_handler():
global a, b, c, d
d = d + 1
if d == 10:
d = 0
global c
c = c + 1
if c == 10:
c = 0
global b
if b == 6:
b = 0
global a
a = a + 1
frame = simplegui.create_frame('Testing', 390, 300)
frame.set_canvas_background('Blue')
button1 = frame.add_button(
'start',
start,
100,
)
button2 = frame.add_button('stop', stop, 100)
button3 = frame.add_button('restart', reset, 100)
frame.set_draw_handler(draw_handler)
timer = simplegui.create_timer(interval, timer_handler)
frame.start()
global counter
counter += 1
# define draw handler
def draw(canvas):
canvas.draw_text(format(counter), (75, 120), 64, 'White')
canvas.draw_text(str(wins) + "/" + str(stops), (240, 30), 30, 'White')
# create frame
frame = simplegui.create_frame("frame", 300, 200)
timer = simplegui.create_timer(100, time_handler)
# register event handlers
frame.set_draw_handler(draw)
label0 = frame.add_label('Stop the timer at 5 seconds intervals!')
label1 = frame.add_label('')
button1 = frame.add_button('Start', start, 100)
label2 = frame.add_label('')
button2 = frame.add_button("Stop", stop, 100)
label3 = frame.add_label('')
button3 = frame.add_button("Reset", reset, 100)
# start frame
frame.start()
count = 0
stop = True
total_stops = 0
succes_stops = 0
timer.stop()
def tick():
global count
count += 1
def draw(canvas):
text = format(count)
canvas.draw_text( text, (80, 125), 42, "white")
canvas.draw_text(str(succes_stops) + '/' + str(total_stops), (190,30), 24, "pink")
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()
def score():
global totalStops, goalStop
return str(goalStop) + "/" + str(totalStops)
# timer and draw handlers
def tick():
global seconds
seconds = int(seconds)
seconds = seconds + 1
def draw_handler(canvas):
global seconds
#seconds = str(seconds)
canvas.draw_text((format(seconds)), (120, 150), 24, 'White')
canvas.draw_text((score()), (250, 20), 20, 'White')
# create frame
frame = simplegui.create_frame("Timer", 300, 300)
timer = simplegui.create_timer(100, tick)
frame.set_draw_handler(draw_handler)
start = frame.add_button('Start', start_handler)
stop = frame.add_button('Stop', stop_handler)
reset = frame.add_button('Reset', reset_handler)
# start frame
frame.start()
x = random.randrange(0, width)
y = random.randrange(0, height)
position[0] = x
position[1] = y
# Handler to draw on canvas
def draw(canvas):
canvas.draw_text(message, position, 36, "Red")
# Create a frame
frame = simplegui.create_frame("Home", width, height)
# Register event handlers
text = frame.add_input("Message:", update, 150)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(interval, tick)
# Start the frame animation
frame.start()
timer.start()
--------------------------------------------------------------------
# Counter ticks
###################################################
# Student should add code where relevant to the following.
import simplegui
counter = 0
# Timer handler
# handlers
def draw(canvas):
global x, y, change, message
print x, y, change
canvas.draw_text(message, (x, y), 30, "Red")
def toggle():
global change
if (change == False):
change = True
else:
change = False
def update_message(txt):
global message
message = txt
# create frame
frame = simplegui.create_frame("screensaver", 500, 500)
toggle = frame.add_button("Toggle", toggle, 100)
input_txt = frame.add_input("message", update_message, 200)
timer = simplegui.create_timer(1000, changeCartetian)
frame.set_draw_handler(draw)
# register
frame.start()
timer.start()
# define event handler for timer with 0.1 sec interval
def increment():
global milliseconds
milliseconds = milliseconds + 1
# define draw handler
def draw(canvas):
global wins
global total_attempts
game = str(wins) + '/' + str(total_attempts)
canvas.draw_text(format(milliseconds), [125, 100], 24, 'white')
canvas.draw_text(game, [265, 15], 24, 'red')
# create frame
frame = simplegui.create_frame("StopWatch", 300, 200)
# register event handlers
frame.add_button("Start", start, 100)
frame.add_button("Stop", stop, 100)
frame.add_button("Restart", reset, 100)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(100, increment)
# start frame
frame.start()
# Please remember to review the grading rubric
# define event handler for timer with 0.1 sec interval
def milli():
global milliseconds
milliseconds = milliseconds + 1
#print milliseconds
format(milliseconds)
# define draw handler
def curr_time(canvas):
canvas.draw_text(str(current_time), (100, 150), 30, 'White')
canvas.draw_text(str(score), (250, 35), 30, 'Green')
# create frame
frame = simplegui.create_frame("Stopwatch Game", 300, 300)
frame.set_draw_handler(curr_time)
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, milli)
# start frame
frame.start()
# Please remember to review the grading rubric
main_list[(y * 3) + x] = turn_control['p']
if win_check(main_list, turn_control['p']) == False:
turn_change()
computer_AI()
else:
in_play = False
def new_game():
global turn, turn_control, main_list, in_play
timer.stop()
main_list = [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
turn = random.choice(['p', 'c'])
in_play = True
if turn == 'p':
turn_control['p'] = 'X'
turn_control['c'] = 'O'
else:
turn_control['c'] = 'X'
turn_control['p'] = 'O'
computer_AI()
frame = simplegui.create_frame('Tic-Tac-Toe', width, height)
timer = simplegui.create_timer(500, new_game)
frame.add_button('New Game', new_game)
frame.set_mouseclick_handler(click)
frame.set_canvas_background('orange')
frame.set_draw_handler(draw)
frame.start()
def keydown(key):
global chag
if key == simplegui.KEY_MAP["space"]:
chag = [0, 0]
def draw(canvas):
canvas.draw_polygon([[50, 50], [180, 50], [180, 140], [50, 140]],
line_width, 'Red')
canvas.draw_circle(POS, radius, line_width, 'Green')
frame = simplegui.create_frame("Quiz4b, Q9", WIDTH, HEIGHT)
timer = simplegui.create_timer(t_interval, timer)
frame.set_keydown_handler(keydown)
frame.set_draw_handler(draw)
frame.start()
timer.start()
# Quiz 4b, Question 9
# http://www.codeskulptor.org/#user39_5PqX3jJTBCIXiLi_7.py
import simplegui
WIDTH = 200
HEIGHT = 100
var = 5
text_width = FRAME.get_canvas_textwidth(text, font_size)
canvas.draw_text(text, ((CANVAS_WIDTH - text_width) // 2,
CANVAS_HEIGHT // 2 + font_size // 4), font_size,
'Green')
def stop_all(): # type: () -> None
"""Handler function to the Quit button."""
TIMER.stop()
SOUND.pause()
FRAME.stop()
# Main
SOUND = simplegui.load_sound(
'http://commondatastorage.googleapis.com/codeskulptor-assets/Epoq-Lepidoptera.ogg'
) # noqa
SOUND.play()
FRAME = simplegui.create_frame('Stop example', CANVAS_WIDTH, CANVAS_HEIGHT)
FRAME.add_button('Quit', stop_all)
FRAME.set_draw_handler(draw)
TIMER = simplegui.create_timer(1000, click)
TIMER.start()
FRAME.start()
def up(key):
if key in CLCK_WISE.keys():
my_ship.change_angle_vel(CLCK_WISE[key], False)
if key == simplegui.KEY_MAP["up"]:
my_ship.thrust_switch()
# 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([-10, -10], [0, 0], my_ship.angle, 0, missile_image,
missile_info, missile_sound)
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(down)
frame.set_keyup_handler(up)
timer = simplegui.create_timer(1000.0, rock_spawner)
sound = simplegui.create_timer(25000.0, sound_restart)
# get things rolling
timer.start()
frame.start()
current_map[y][x] = MAP_TILE
elif lastUpdated == 3: # distructable
current_map[y][x] = DISTRUCTABLE_TILE
elif lastUpdated == 4: # indistructable
current_map[y][x] = UNDISTRUCTABLE_TILE
# Create a frame and assign callbacks to event handlers
frame = simplegui.create_frame('Bomberman : ' + VER, SCREEN_WIDTH,
SCREEN_HEIGHT)
frame.set_draw_handler(draw_handler)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(mouse_handler)
leTimer = simplegui.create_timer(TIMER_INTERVAL, moving_objects)
leTimer.start()
button1 = frame.add_button('Inc Speed', button_speed, 150)
label1 = frame.add_label('Speed = 1')
button2 = frame.add_button('Dec Speed', button_speedd, 150)
label11 = frame.add_label(' ')
button3 = frame.add_button('Inc Fire Range', button_fire, 150)
label2 = frame.add_label('Fire = 1')
button4 = frame.add_button('Dec Fire Range', button_fired, 150)
label12 = frame.add_label(' ')
button5 = frame.add_button('Inc Bomb Number', button_bombs, 150)
global t
t += 1
def t3_h():
global t
while t != 0:
t -= 1
def d_h(canvas):
canvas.draw_circle(b_p, 5, 1, "red", "white")
def r_h():
v[0] = 0
v[1] = 0
b_p[0] = 200
b_p[1] = 200
frame1 = simplegui.create_frame("velocity program", 400, 400)
frame1.set_draw_handler(d_h)
frame1.add_button("reset", r_h)
frame1.set_keydown_handler(kd_h)
frame1.set_keyup_handler(ku_h)
timer1 = simplegui.create_timer(10, t_h)
timer2 = simplegui.create_timer(1000, t2_h)
timer3 = simplegui.create_timer(100, t3_h)
frame1.start()
timer1.start()
"Timer 1: " + str(counter1[0] % 10) + "." + str(counter1[1]),
[50, 100], 24, "White")
canvas.draw_text(
"Timer 2: " + str(counter2[0] % 10) + "." + str(counter2[1]),
[50, 200], 24, "White")
# Register event handlers.
frame = simplegui.create_frame("Mystery bug", 300, 300)
frame.add_button("Start timer1", start1, 200)
frame.add_button("Stop timer1", stop1, 200)
frame.add_button("Start timer2", start2, 200)
frame.add_button("Stop timer2", stop2, 200)
frame.set_draw_handler(draw)
timer1 = simplegui.create_timer(100, tick1)
timer2 = simplegui.create_timer(100, tick2)
# Start frame.
frame.start()
# optional exercises 4 Practice for key events
# 1) debugging a program that uses key events
#imports
import simplegui
#globals
message = "Welcome!"
card[tick] = list_1[i * 4 + j]
card_index[tick] = i * 4 + j
tick += 1
def run():
global rec_color, rec_color_code, count
for i in range(0, 4):
for j in range(0, 4):
if rec_color_code[i * 4 + j] == 0 and count < 2:
rec_color[i * 4 + j] = "red"
elif rec_color_code[i * 4 + j] == 0 and count >= 2:
rec_color_code[i * 4 + j] = 2
elif rec_color_code[i * 4 + j] == 1:
rec_color[i * 4 + j] = "green"
else:
rec_color[i * 4 + j] = "yellow"
rec_color_code[i * 4 + j] = 2
count += 1
frame = simplegui.create_frame("Memory", 200, 400)
frame.set_draw_handler(draw)
frame.set_mouseclick_handler(click)
frame.add_button("New Game", new_game, 150)
frame.add_label("Turns")
label = frame.add_label(str(turn))
timer = simplegui.create_timer(100, run)
frame.start()
timer.start()
"""Change message on mouse click."""
global message
message = "Good job!"
def draw(canvas):
"""Draw message."""
canvas.draw_text(message, [50, 112], 36, "Red")
# Create a frame and assign callbacks to event handlers
frame = simplegui.create_frame("Home", 300, 200)
frame.add_button("Click me", click)
frame.set_draw_handler(draw)
#####################
# Buggy code -- doesn't start timers
def timer1_handler():
print "1"
def timer2_handler():
print "2"
simplegui.create_timer(100, timer1_handler)
simplegui.create_timer(300, timer2_handler)