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 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 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 __init__(self, simulation):
"""
Create frame and timers, register event handlers
"""
self._simulation = simulation
self._grid_height = self._simulation.get_grid_height()
self._grid_width = self._simulation.get_grid_width()
self._frame = simplegui.create_frame("Zombie Apocalypse simulation",
self._grid_width * CELL_SIZE,
self._grid_height * CELL_SIZE)
self._frame.set_canvas_background("White")
self._frame.add_button("Clear all", self.clear, 200)
self._item_type = OBSTACLE
self._item_label = self._frame.add_button(
LABEL_STRING + self._item_type, self.toggle_item, 200)
self._frame.add_button("Humans flee", self.flee, 200)
self._frame.add_button("Zombies stalk", self.stalk, 200)
self._frame.add_button("Auto Flee (toggle)", self.auto_flee, 200)
self._frame.add_button("Auto Stalk (toggle)", self.auto_stalk, 200)
self._frame.add_button("Full Pursuit (toggle stalk and flee)",
self.full_pursuit, 200)
self._frame.set_mouseclick_handler(self.add_item)
self._frame.set_draw_handler(self.draw)
self._stalk_on = False
self._flee_on = False
def get_frame(self):
frame = simplegui.create_frame(
self.title,
self.width,
self.height)
frame.set_canvas_background(self.bg_color)
return frame
def new_game(range):
print "\n\n Let's play guess the number, fellow!"
# initialize global variables used in your code here
global secret_number # computer secret number
global allowed_guesses # max guesses by the player
global guesses_count# saving number of guesses on each match
global chooserange #range chosen
# init guesses count as 1 on each match (first try)
guesses_count = 1
if int(range) == 1000:
secret_number = range1000()
allowed_guesses = 10
chooserange = 1000
else:
secret_number = range100()
allowed_guesses = 7
chooserange = 100
# to see what is the secret number range which computer
# is choosing to play with
# please uncomment the following line
#print "secret number", secret_number
frame = simplegui.create_frame("Guess the number",200,200)
frame.add_button("Range 0-100", range_handler100)
frame.add_button("Range 0-1000", range_handler1000)
frame.add_input('Guess the number:', input_guess, 100)
frame.start()
def start(self):
self.frame = simplegui.create_frame(self.title,
self.width,
self.height)
self.frame.set_draw_handler(self.draw)
self.frame.start()
self.my_setup()
def __init__(self):
self.frame = simplegui.create_frame('2048', 490, 490)
self.frame.add_button('New Game', self.start)
self.frame.set_keydown_handler(self.keydown)
self.frame.set_draw_handler(self.draw)
self.text = self.frame.add_label('')
self.frame.start()
def __init__(self):
self.frame = simplegui.create_frame("Flappy Bird", GAME_WIDTH, GAME_HEIGHT)
self.frame.start()
self.background = Background()
self.bird = Bird()
self.register_handlers()
self.pipe_creator = PipeCreator()
def __init__(self, numpairs, card_size, columns):
# Set board width, height
self.width = (card_size[0] * columns) + (CARD_MARGIN * columns + CARD_MARGIN)
numrows = (numpairs * 2)/columns
if (numpairs * 2)%columns > 0:
numrows += 1
self.height = (card_size[1] * numrows) + (CARD_MARGIN * numrows + CARD_MARGIN) + SCORE_MARGIN
# Create the frame and buttons
self.frame = simplegui.create_frame("Memory", self.width, self.height)
self.frame.add_button("Reset", self.reset_game)
# Set cards
self.numpairs = numpairs
self.card_size = card_size
self.columns = columns
self.cards = Cards(self.numpairs, self.card_size, self.columns)
# Set scoreboard
self.scoreboard = Scoreboard()
# Register event handlers
self.frame.set_mouseclick_handler(self.on_mouseclick)
self.frame.set_draw_handler(self.draw)
# Start the frame
self.frame.start()
def handle_gui_frame():
gframe = simplegui.create_frame( "Electronic Stop Watch", 200, 200)
gframe.set_draw_handler(draw_text_to_canvas)
gframe.add_button( "Start", start_stop_watch, 150)
gframe.add_button( "Stop", stop_stop_watch, 150)
gframe.add_button( "Reset", reset_stop_watch, 150)
gframe.start()
def __init__(self):
self.drag_manager = DragManager()
self.apoint = Point((10,110))
self.drag_manager.add_dragable_item(self.apoint)
self.bpoint = Point((30,110))
self.drag_manager.add_dragable_item(self.bpoint)
self.cpoint = Point((50,110))
self.drag_manager.add_dragable_item(self.cpoint)
self.arectangle = Rectangle((20,20),(40,220)) # a square is a rectangle smh
#self.drag_manager.add_dragable_item(self.arectangle)
self.arectangle1 = Rectangle((40,200),(300,220))
self.arectangle2 = Rectangle((280,20),(300,220))
self.arectangle3 = Rectangle((20,20),(300,40))
self.acircle = Circle((100,300),50)
self.drag_manager.add_dragable_item(self.acircle)
self.aball = Ball()
#self.drag_manager.add_dragable_item(self.aball)
#self.aball.walls.append(self.arectangle)
self.apaddle = Paddle((45,41),(55,91))
self.apaddle.walls.append(self.arectangle1)
self.apaddle.walls.append(self.arectangle3)
self.bpaddle = Paddle((265,41),(275,91))
self.bpaddle.walls.append(self.arectangle1)
self.bpaddle.walls.append(self.arectangle3)
self.ab2 = Ball((43,151),5,(-100.0,55.0))
self.ab2.color = "purple"
self.ab2.walls.append(self.arectangle)
self.ab2.walls.append(self.arectangle1)
self.ab2.walls.append(self.arectangle2)
self.ab2.walls.append(self.arectangle3)
self.ab2.walls.append(self.apaddle)
self.ab2.walls.append(self.bpaddle)
self.drag_manager.add_dragable_item(self.bpaddle)
self.drag_manager.add_dragable_item(self.apaddle)
self.drag_manager.add_dragable_item(self.ab2)
self.atri = Triangle((25,200),(40,240),(60,150))
self.drag_manager.add_dragable_item(self.atri)
self.frame = simplegui.create_frame('Testing', 400, 400)
self.frame.set_draw_handler(self.draw)
self.frame.set_mouseclick_handler(self.mouse_click_handler)
self.frame.set_mousedrag_handler(self.mouse_drag_handler)
self.frame.set_keydown_handler(self.key_down)
self.frame.start()
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):
self.button_manager = ButtonManager()
self.draw_manager = DrawManager()
self.garbage = Garbage()
self.draw_manager.add_draw_item(self.garbage)
self.drag_manager = DragManager(self, self.garbage)
self.drag_manager.add_dragable_item(self.garbage)
self.fridge = Fridge()
self.draw_manager.add_draw_item(self.fridge)
self.add_word_button = AddWordButton(self,"add word",(390,20),(450,40))
self.button_manager.add_button(self.add_word_button)
self.draw_manager.add_draw_item(self.add_word_button)
self.drag_manager.add_dragable_item(self.add_word_button)
self.frame = simplegui.create_frame('fridge poetry',600, 780,0)
self.frame.set_draw_handler(self.draw)
self.frame.set_mouseclick_handler(self.mouse_click_handler)
self.frame.set_mousedrag_handler(self.mouse_drag_handler)
self.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):
self.wins = 0
self.losses = -1
self.deck = Deck()
random.shuffle(self.deck.cards)
#print(str(self.deck))
self.dealer_hand = Hand(( 10, 50),"Dealer")
self.player_hand = Hand((100,210),"Player 1")
self.draw_manager = DrawManager()
self.button_manager = ButtonManager()
self.game_label = Label(self,"BlackJack",(200,20), (400,35))
self.game_label.color = "Black"
self.game_label.text_color = "Green"
self.game_label.font_size = 36
self.deal_button = DealButton(self,"Deal",(20,400),(100,440))
self.deal_button.color = 'Green'
self.button_manager.add_button(self.deal_button)
self.draw_manager.add_draw_item(self.deal_button)
self.hit_button = HitButton(self,"Hit",(110,400),(190,440))
self.hit_button.color = 'Gold'
self.button_manager.add_button(self.hit_button)
self.draw_manager.add_draw_item(self.hit_button)
self.stand_button = StandButton(self,"Stand",(200,400),(280,440))
self.stand_button.color = 'Red'
self.button_manager.add_button(self.stand_button)
self.draw_manager.add_draw_item(self.stand_button)
self.result_label = Label(self,"Good Luck", (350,400),(500,440) )
self.draw_manager.add_draw_item(self.result_label)
self.wins_label = Label(self,"Wins - 0", (510,400),(600,420) )
self.draw_manager.add_draw_item(self.wins_label)
self.losses_label = Label(self,"Losses - 0", (510,420),(600,440) )
self.draw_manager.add_draw_item(self.losses_label)
self.deal_button.click()
self.result_label.text = "Good Luck"
self.draw_manager.add_draw_item(self.game_label)
self.draw_manager.add_draw_item(self.player_hand)
self.draw_manager.add_draw_item(self.dealer_hand)
self.tic_tm = TimerManager(1000)
#self.tic_tm.add_listener(self, Signal("tic"))
self.frame = simplegui.create_frame('BlackJack',630, 500,100)
self.frame.set_draw_handler(self.draw_handler)
self.frame.set_mouseclick_handler(self.mouse_click_handler)
self.frame.start()
def new_game():
# initialize global variables used in your code here
global count
frame = simplegui.create_frame("guess number" , 300 ,300)
frame.add_button("range100" , range100)
frame.add_button("range1000" , range1000)
frame.add_input("input_guess" , input_guess , 100)
# remove this when you add your code
frame.start()
def __init__(self, tree):
"""
Create GUI
"""
self._tree = tree
self._canvas_width, self._canvas_height = self.get_box_size(tree)
self._frame = simplegui.create_frame("Draw a tree", self._canvas_width, self._canvas_height)
self._frame.set_canvas_background("White")
self._frame.set_draw_handler(self.draw)
self._frame.start()
def __init__(self, record):
self.frame = simplegui.create_frame("Flappy Bird", GAME_WIDTH, GAME_HEIGHT)
self.frame.start()
self.background = Background()
self.bird = Bird()
self.register_handlers()
self.pipe_creator = PipeCreator()
self.score = Score()
self.record = record
self.game_over = False
def Stopwatch():
frame = simplegui.create_frame("StopWatch",300,200)
frame.start()
Reset()
frame.add_button("Start",Start,100)
frame.add_button("Stop",Stop,100)
frame.add_button("Reset",Reset,100)
frame.add_label('')
frame.add_button("Dual-Game (Optional)",Dual_game,150)
frame.set_draw_handler(draw)
def run_gui():
"""
Create a frame and assign draw handler
"""
frame = simplegui.create_frame("Indexed grid", CANVAS_WIDTH, CANVAS_HEIGHT)
frame.set_canvas_background("White")
frame.set_draw_handler(draw)
# Start the frame animation
frame.start()
def __init__(self):
self.stage = Stage()
self.bird = Bird()
self.score = Score()
self.pipes = Pipes()
self.frame = simplegui.create_frame("Flappy Bird", FRAME_WIDTH, FRAME_HEIGHT)
self.game_is_over = False
self.is_started = False
self.is_robot_on = False
self.register_handlers()
def setup():
#frame
global frame
frame = simplegui.create_frame("Guess the Number", 200, 200)
#buttons
range100_button = frame.add_button("Range 0-100", range100, 100)
range1000_button = frame.add_button("Range 0-1000", range1000, 100)
#input field
inp = frame.add_input("Enter your guess: ", get_input, 100)
def __init__(self):
"""
Initializer to create frame, sets handlers and initialize list of balls to be empty
"""
self.simulation = Simulation()
self._frame = simplegui.create_frame("ball/ball collision simulator",
CANVAS_WIDTH, CANVAS_HEIGHT)
self._frame.set_draw_handler(self.draw)
self._frame.set_mouseclick_handler(self.click)
self._prev_time = time.time()
self._frame_rate = 60.0
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 Dual_game():
f = simplegui.create_frame("Dual-Game",300,200)
f.start()
Reset()
f.add_button("Start",Start,150)
f.add_button("Player1 press[q]",player1,150)
f.add_button("Player2 press[p]",player2,150)
f.add_button("Reset",Reset,150)
f.set_keydown_handler(player_key)
f.add_label('')
f.add_button("Back to Stopwatch",Stopwatch,150)
f.set_draw_handler(draw_dual)
def __init__(self):
"""
Create a game
"""
self.frame = simplegui.create_frame("Doodle Jump", CANVAS_WIDTH, CANVAS_HEIGHT)
self.frame.set_keydown_handler(self.keydown)
self.frame.set_keyup_handler(self.keyup)
self.frame.set_draw_handler(self.draw)
self.camera_pos = [0, 0]
self.platform_list = [Platform(idx * PLATFORM_SPACING) for idx in range(0, NUM_PLAT)]
self.my_doodle = DoodleJumper([(self.platform_list[0].left + self.platform_list[0].right) / 2, 200])
self.frame.start()
def init_gui(self):
""" Intialize Graphics User Interface ( GUI )"""
global frame
global label
# 6 Create frame
frame = simplegui.create_frame("Pairs", self.WIDTH, self.HEIGHT)
# 7 Register event handlers for control elements
frame.set_draw_handler(self.draw)
frame.add_button("Restart", self.init)
frame.set_mouseclick_handler(self.mouseclick)
label=frame.add_label("Moves = 0")
return
def build_game(self):
# create timer and frame
self.frame = simplegui.create_frame("Blackjack", CANVAS_W, CANVAS_H)
self.cards_url = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/cards.jfitz.png")
self.card_back = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/card_back.png")
# register event handlers
self.frame.add_button(" Deal ", self.deal, 100)
self.frame.add_button(" Hit ", self.hit, 100)
self.frame.add_button(" Stand ", self.stand, 100)
self.frame.set_draw_handler(self.draw_handler)
self.frame.set_canvas_background("Green")
# start frame
self.frame.start()
def __init__(self):
"""
Create a frame and load the cancer data
"""
self._frame = simplegui.create_frame("Cancer risk visualization", CANVAS_WIDTH, CANVAS_HEIGHT)
self._frame.set_canvas_background("White")
self._frame.set_draw_handler(self.draw)
self._frame.add_input("Enter cutoff (scaled by 0.00001)", self.enter_cutoff, 200)
self._frame.add_button("Print data table in CSV", self.print_table, 200)
self._data_table = self.load_data()
self.enter_cutoff("0.0")
self._USA_Counties = simplegui.load_image(MAP_URL)
self._frame.start()
stop()
t=0
# define event handler for timer with 0.1 sec interval
def tick():
global t
t+=1
# define draw handler
def draw(canvas):
canvas.draw_text(format(t),(60,100),32,"white")
canvas.draw_text(str(win)+"/"+str(total),[130,30],32,"green")
# create frame
frame=simplegui.create_frame("Home",200,200)
timer=simplegui.create_timer(100,tick)
# register event handlers
frame.set_draw_handler(draw)
frame.add_button("Start",start,100)
frame.add_button("Stop",stop,100)
frame.add_button("Reset",reset,100)
# start frame
frame.start()
# Please remember to review the grading rubric
def input_guess(guess):
global count
global n
print "count is ", count
global secret_number
guess = float(guess)
print "guess was", guess
if (count < n):
count = count + 1
if secret_number > guess:
print "higher"
elif secret_number < guess:
print "lower"
elif secret_number == guess:
print "that's it. played well!"
new_game()
print("number of chances left", (n - count))
else:
print "chances over, you lose"
new_game()
frame = simplegui.create_frame("Guess The Number", 300, 300)
frame.add_button("Range from [0,100)", range100, 200)
frame.add_button("Range from [0,1000)", range1000, 200)
frame.add_input("Enter guess", input_guess, 100)
frame.start()
new_game()
def keydown(key):
# global POS
if key == simplegui.KEY_MAP["space"]:
POS[0] += chag[0]
POS[1] += chag[1]
def draw_handler(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)
frame.set_keydown_handler(keydown)
frame.set_draw_handler(draw_handler)
frame.start()
# Modified version1, press space-bar down will stop the moving point.
# http://www.codeskulptor.org/#user39_5PqX3jJTBCIXiLi_11.py
import simplegui
POS = [10, 20]
chag = [3, 0.7]
WIDTH = 250
HEIGHT = 200
radius = 2
import simplegui
pos = []
def click(position):
global pos
pos = position
def draw(canvas):
canvas.draw_text("Mouse click at " + str(pos), [200, 200], 30, "Red")
frame = simplegui.create_frame("Mouse Click", 640, 420)
frame.set_canvas_background("white")
frame.start()
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)
###################################################
# Sample output
#Mouse click at (104, 105)
#Mouse click at (169, 175)
#Mouse click at (197, 135)
#Mouse click at (176, 111)
#Mouse click at (121, 101)
#Mouse click at (166, 208)
for k in range(len(pairs)):
canvas.draw_text(str(pairs[k]), (k * 50 + 16, 60), 40, "teal")
for k in range(size * 2):
if clicked[k] == True:
canvas.draw_polygon([(k * 50, 0), ((k + 1) * 50, 0),
((k + 1) * 50, 100), (k * 50, 100)], 1,
"gray")
else:
canvas.draw_polygon([(k * 50, 0), ((k + 1) * 50, 0),
((k + 1) * 50, 100), (k * 50, 100)], 1,
"Yellow", "teal")
# create frame and add a button and labels
frame = simplegui.create_frame("Memory", size * 100, 100)
frame.set_canvas_background('Silver')
frame.add_button("Reset", new_game)
inp = frame.add_label('Turn = 0', 50)
inp.set_text('Turn =' + str(turn))
# register event handlers
frame.set_mouseclick_handler(mouseclick)
frame.set_draw_handler(draw)
# get things rolling
new_game()
frame.start()
width = 500
height = 500
interval = 2000
# Handler for text box
def update(text):
global message
message = text
# Handler for timer
def tick():
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()
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()
#asigning image constants as CENTER and SIZE appropriately
DECK_SIZE = [WIDTH, HEIGHT]
DECK_CENTER = [WIDTH / 2, HEIGHT / 2]
#individual cards in the deck
CARD_WIDTH = 167
CARD_HEIGHT = 242
#card_center = [10 * CARD_WIDTH + CARD_WIDTH / 2 , 2 * CARD_HEIGHT + CARD_HEIGHT / 2]
card_size = [CARD_WIDTH, CARD_HEIGHT]
card_center = [12 * (167 + 0.5) + 83.5, 1 * (242 + 1) + 121]
#frame dimensions
SCALE = 2
FRAME_SIZE = [DECK_SIZE[0] / SCALE, DECK_SIZE[1] / SCALE]
frame_center = [DECK_CENTER[0] / SCALE, DECK_CENTER[1] / SCALE]
#define draw handler
def draw(canvas):
canvas.draw_image(deck_of_cards, card_center, card_size, frame_center,
card_size)
#create frame and register handlers
frame = simplegui.create_frame("My Deck of cards", FRAME_SIZE[0],
FRAME_SIZE[1], 70)
frame.set_draw_handler(draw)
#start frame
frame.start()
elif dealer_hand.get_value() >= player_hand.get_value():
in_play = False
outcome = 'DEALER WINS'
else:
outcome = 'YOU WON!'
#- draw handler
def draw(canvas):
dealer_hand.draw(canvas, [100, 50])
player_hand.draw(canvas, [100, 250])
canvas.draw_text('BlackJack!', (375, 40), 50, 'black')
canvas.draw_text('Dealer hand:', (50, 40), 25, 'black', 'sans-serif')
canvas.draw_text('Player hand: ', (50, 240), 25, 'black', 'sans-serif')
canvas.draw_text(outcome, (50, 375), 20, 'yellow')
# initialization frame
frame = simplegui.create_frame("Blackjack", 600, 400)
frame.set_canvas_background("Green")
# buttons and canvas callback
frame.add_button("Deal", deal, 200)
frame.add_button("Hit", hit, 200)
frame.add_button("Stand", stand, 200)
frame.set_draw_handler(draw)
#- and go!
deal()
frame.start()
''' review the grading rubric '''
if key_pressed.get("state") == "down" and key_pressed.get(
"button") == "left":
firing_angle += FIRING_ANGLE_VEL_INC
print key_pressed
elif key_pressed.get("state") == "down" and key_pressed.get(
"button") == "right":
firing_angle -= FIRING_ANGLE_VEL_INC
print key_pressed
#draw firing line
orient = angle_to_vector(firing_angle)
upper_endpoint = [
FIRING_POSITION[0] + FIRING_LINE_LENGTH * orient[0],
FIRING_POSITION[1] - FIRING_LINE_LENGTH * orient[1]
]
canvas.draw_line(FIRING_POSITION, upper_endpoint, 4, "White")
# update a_bubble and check for sticking
# draw a bubble and stuck bubbles
# create frame and register handlers
frame = simplegui.create_frame("Bubble Shooter", WIDTH, HEIGHT)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.set_draw_handler(draw)
# create initial buble and start frame
frame.start()
play_endless = False
while play_endless == False:
try:
menu = Menu()
break
except TypeError:
level = Level(1)
if level.getLevel() == 1:
mixer.music.load("All Star 8 Bit.mp3")
mixer.music.play(-1)
elif level.getLevel() == 1.5:
mixer.music.load("harder_better_faster_stronger.mp3")
mixer.music.play(-1)
elif level.getLevel() == 2:
mixer.music.load("Thriller (8 Bit).mp3")
mixer.music.play(-1)
frame = simplegui.create_frame('Half-Life 3', 500, 700)
frame.set_draw_handler(draw)
frame.set_keyup_handler(keyUp)
frame.set_keydown_handler(keyDown)
frame.start()
play_endless = True
# Display "This is easy?"
###################################################
# Student should add code where relevant to the following.
import simplegui
# Draw handler
def draw(canvas):
canvas.draw_text("This is easy?", [100, 100], 24, "White")
# Create frame and assign callbacks to event handlers
frame = simplegui.create_frame("This is easy", 400, 200)
frame.set_draw_handler(draw)
# Start the frame animation
frame.start()
countstop = 0
x = 0
y = 0
status = "false"
timer.stop()
# define event handler for timer with 0.1 sec interval
def tick():
global tenth
tenth += 1
def draw(canvas):
canvas.draw_text(format(x), [230,200], 48, "Orange")
canvas.draw_text(attempt(y), [520,50], 40, "Green")
# create frame
frame = simplegui.create_frame("Stopwatch The Game", 600, 400)
# register event handlers
f = frame.add_button("Start", start, 150)
f = frame.add_button("Stop", stop, 150)
f = frame.add_button("Reset", reset, 150)
frame.set_draw_handler(draw)
timer = simplegui.create_timer(100, tick)
# start timer and frame
frame.start()
#timer.start()
# remember to review the grading rubric
paddle2_vel -= 4
elif key == simplegui.KEY_MAP["down"]:
paddle2_vel += 4
def keyup(key):
global paddle1_vel, paddle2_vel
if key == simplegui.KEY_MAP["w"]:
paddle1_vel += 4
elif key == simplegui.KEY_MAP["s"]:
paddle1_vel -= 4
elif key == simplegui.KEY_MAP["up"]:
paddle2_vel += 4
elif key == simplegui.KEY_MAP["down"]:
paddle2_vel -= 4
# 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_label('Press the "Reastart" bottom to start a new game')
frame.add_label(" ", 80)
frame.add_button("Restart", new_game, 180)
# start frame
#new_game()
frame.start()
if trial < allowed_trial + 1:
print "Guess was:", guess_num
if guess_num > num_range:
warning(guess_num, num_range)
else:
print "Number of remainin trial=", allowed_trial - trial
if guess_num > secret_num:
print "Higher !"
elif guess_num < secret_num:
print "Lower !"
else:
print "Correct ! You are winner!"
elif trial == allowed_trial + 1:
print "Sorry! You loose...Play next game!"
pass
#===================== create frame =======================
frm = simplegui.create_frame("guess_the _number!", 300, 300)
#================= event handlers =========================
frm.add_button("Range is [0,100)", range100, 200)
frm.add_button("Range is [0,1000)", range1000, 200)
frm.add_input("Enter a guess", input_guess, 200)
#============== call new_game =============================
new_game()
#====================<><><>================================
global counter
print counter
counter += 1
# the clock resets when reaches 10 minutes
if counter >= 6000:
reset()
# define draw handler
def draw(canvas):
global x, y
time = format(counter)
canvas.draw_text(time, [60, 110], 36, "White")
canvas.draw_text(str(x) + "/" + str(y), [150, 20], 24, "Green")
# create frame
frame = simplegui.create_frame("Stopwatch", 200, 200)
# 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)
timer = simplegui.create_timer(100, tick)
# start frame
frame.start()
# Please remember to review the grading rubric
#do nothing
pass
pass
def draw(canvas):
global l, turns
#draw dividing line
for i in range(MAX_NUMBER * 2):
canvas.draw_line((i * WIDTH / 2 / MAX_NUMBER, HEIGHT),
(i * WIDTH / 2 / MAX_NUMBER, 0), 1, "Black")
#draw cards that already overturn
for i in range(MAX_NUMBER * 2):
if is_overturn[i] == True:
#show number
canvas.draw_text(str(cards[i]), (i * WIDTH / MAX_NUMBER / 2, 90),
100, "White")
l.set_text("Turns = %d" % turns)
frame = simplegui.create_frame("Memory", WIDTH, HEIGHT)
frame.add_button("Restart", new_game)
l = frame.add_label("Turns = 0")
frame.set_mouseclick_handler(mouseclick)
frame.set_draw_handler(draw)
frame.set_canvas_background('Green')
new_game()
frame.start()
state = 1
# update information about game turn
Turns = 'Turns = ' + str(counter // 2)
label.set_text(Turns)
# cards are logically 50x100 pixels in size
def draw(canvas):
start_point = 10 # make text align center
# check whether card filp or not
for number in range(len(card_list)):
pos = 50 * number
if exposed[number] == True:
canvas.draw_text(str(card_list[number]),(start_point + pos , 70), 50 , 'white')
else:
canvas.draw_polygon([(pos , 0), (pos , 100), (50 + pos , 100), (50 + pos , 0)], 3, 'black','green')
# create frame and add a button and labels
frame = simplegui.create_frame("Memory", 800, 100)
frame.add_button("Reset", new_game)
label = frame.add_label("Turns = 0")
# register event handlers
frame.set_mouseclick_handler(mouseclick)
frame.set_draw_handler(draw)
# get things rolling
new_game()
frame.start()
# Always remember to review the grading rubric
global time
time += 1
timer = simplegui.create_timer(interval, timer_handler)
# define draw handler
def draw(canvas):
canvas.draw_text(format(time),[100, 100], 40, "White")
canvas.draw_text(str(success)+'/'+str(attempts),[200, 50], 30, "Green")
# create frame
frame = simplegui.create_frame("Home", 300, 150)
timer = simplegui.create_timer(interval, timer_handler)
# register event handlers
frame.set_draw_handler(draw)
frame.add_button("start", start, 75)
frame.add_button("stop", stop, 75)
frame.add_button("reset", reset, 75)
count -= 1
print 'Number of remaining guess is ' + str(count)
print 'You ran out of guesses. The number was ' + str(
secret_number) + '\n'
new_game()
elif secret_number > guess:
count -= 1
print 'Number of remaining guess is ' + str(count)
print 'Higher\n'
elif secret_number < guess:
count -= 1
print 'Number of remaining guess is ' + str(count)
print 'Lower\n'
# remove this when you add your code
# create frame
frame = simplegui.create_frame("Guess Number", 100, 200)
# register event handlers for control elements and start frame
frame.add_input("input a number", input_guess, 100)
frame.add_button("Range is [0,100)", range100, 150)
frame.add_button("Range is [0,1000)", range1000, 150)
frame.start
# call new_game
new_game()
# always remember to check your completed program against the grading rubric
new_game()
def input_guess(guess):
global secret, user_guess
user_guess = int(guess)
print ""
if user_guess == secret:
print "Guess was " + str(user_guess)
print "Correct!"
new_game()
elif user_guess > secret:
print "Guess was " + str(user_guess)
print "Lower!"
elif user_guess < secret:
print "Guess was " + str(user_guess)
print "Higher!"
else:
print "Oh, something went wrong!"
number_of_guesses()
frame = simplegui.create_frame("Guess the number", 200, 200)
frame.add_button('Range is [0, 100]', range100, 200)
frame.add_button('Range is [0, 1000]', range1000, 200)
frame.add_input('Enter guess', input_guess, 50)
frame.start()
new_game()
ball_pos[0] += vel[0]
ball_pos[1] += vel[1]
# Draw ball
canvas.draw_circle(ball_pos, BALL_RADIUS, 2, "Red", "White")
def keydown(key):
acc = 1
if key == simplegui.KEY_MAP["left"]:
vel[0] -= acc
elif key == simplegui.KEY_MAP["right"]:
vel[0] += acc
elif key == simplegui.KEY_MAP["down"]:
vel[1] += acc
elif key == simplegui.KEY_MAP["up"]:
vel[1] -= acc
print ball_pos
# create frame
frame = simplegui.create_frame("Velocity ball control", WIDTH, HEIGHT)
# register event handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
# start frame
frame.start()
def keyup(key):
global current_key
current_key = ' '
def draw(c):
# NOTE draw_text now throws an error on some non-printable characters
# Since keydown event key codes do not all map directly to
# the printable character via ord(), this example now restricts
# keys to alphanumerics
if current_key in "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":
c.draw_text(current_key, [10, 25], 20, "Red")
# create frame
f = simplegui.create_frame("Echo", 35, 35)
# register event handlers
f.set_keydown_handler(keydown)
f.set_keyup_handler(keyup)
f.set_draw_handler(draw)
# start frame
f.start()
# control the position of a ball using the arrow keys
import simplegui
format(t)
# define draw handler
#draw handler defination
def draw(canvas):
#canvas.draw_text('A', (20, 20), 12, 'Red')
canvas.draw_text(formatted_time, [100, 150], 25, "White")
canvas.draw_text(str(no_of_success), [200, 40], 25, "Green")
canvas.draw_text("/", [214, 40], 25, "White")
canvas.draw_text(str(no_of_attempts), [225, 40], 25, "Red")
# create frame
#simplegui.create_frame(title, canvas_width, canvas_height)
frame = simplegui.create_frame('MyFrame', 275, 275)
# register event handlers
#frame.add_button('Label 1', button_handler)
frame.add_button("Start", start, 150)
frame.add_button("Stop", stop, 150)
frame.add_button("Reset", reset, 150)
timer = simplegui.create_timer(100, timer_handler)
frame.set_draw_handler(draw)
# start frame
frame.start()
# Please remember to review the grading rubric
d5 = [115, 125]
d6 = [125, 100]
d7 = [140, 160]
d8 = [165, 140]
canvas.draw_polyline([d1, d2, d3, d4, d5, d6, d7, d8], 2, "white")
canvas.draw_circle(d1, 2, 2, "white", "black")
canvas.draw_circle(d2, 2, 2, "white", "black")
canvas.draw_circle(d3, 2, 2, "white", "black")
canvas.draw_circle(d4, 2, 2, "white", "black")
canvas.draw_circle(d5, 2, 2, "white", "black")
canvas.draw_circle(d6, 2, 2, "white", "black")
canvas.draw_circle(d7, 2, 2, "white", "black")
canvas.draw_circle(d8, 2, 2, "white", "black")
frame = simplegui.create_frame("Design", 600, 600)
l1 = frame.add_label(
"click to button Show Design and click again to Remove Design")
l2 = frame.add_label("\n")
l3 = frame.add_label("<<Toggle Buttons>>")
l4 = frame.add_label("\n")
frame.add_button("Fish", fish)
frame.add_button("House", house)
frame.add_button("Flower", flower)
frame.add_button("Dipper", dipper)
#Buttons for Moving The Object
frame.add_label("\n")
frame.add_label("Buttons for moving the object:")
frame.add_label("\n")
frame.add_button("Left Side Scroll Fish", Lfish)
outcome = 'You Win!'
opt = 'New deal?'
score += 1
print 'player score' + str(player.get_value())
print 'dealer score' + str(dealer.get_value())
def draw(canvas):
global outcome, player, dealer, cards, opt, score, in_play
canvas.draw_text('Blackjack', [180, 75], 30, 'Red')
canvas.draw_text('Dealer:', [100, 160], 20, 'Black')
canvas.draw_text('Player:', [100, 360], 20, 'Black')
canvas.draw_text('Score = ' + str(score), [400, 50], 20, 'Black')
canvas.draw_text(outcome, [200, 160], 20, 'Black')
canvas.draw_text(opt, [200, 360], 20, 'Black')
dealer.draw(canvas, True, in_play)
player.draw(canvas, False, in_play)
#初始框架
frame = simplegui.create_frame('Black jack', 600, 600)
frame.set_canvas_background('Green')
#创建按钮和画布
frame.add_button('Deal', deal, 200)
frame.add_button('Hit', hit, 200)
frame.add_button('Stand', stand, 200)
frame.set_draw_handler(draw)
deal()
frame.start()
def increment():
global count
count += 1
def decrement():
global count
count -= 1
def print_count():
print count
frame = simplegui.create_frame("Counter Frame", 100, 200)
frame.add_button("Reset", reset, 150)
frame.add_button("Increment", increment, 150)
frame.add_button("Decrement", decrement, 150)
frame.add_button("Print", print_count, 150)
frame.start()
reset()
increment()
print_count()
increment()
print_count()
reset()
decrement()
# 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
# Python Test 8
# Learning the SimpleGUI custom module and its components
#These commands create frames and modify them.
# Create a new frame for interactive programs
# A frame has a control panel on the left and a canvas on the right
# Syntax: simplegui.create_frame("TITLE", canvas_width, canvas_height, control_width
# The first 3 arguments are required, and all are automatic pixel values
# The canvas_height also affects control panel height
import simplegui
#frame = simplegui.create_frame("MyFF", 100, 100)
myframe = simplegui.create_frame("MySF", 300, 300, 200)
# Change the background color of the frame's canvas (default=black)
# Syntax: FRAME.set_canvas_background("COLOR")
myframe.set_canvas_background("Lime")
# The colors that are supported by this command have odd names given to them
# The color names are capitalized and note that the color is written in quotes
# Begin the frame's interactivity
# Syntax: FRAME.start()
myframe.start()
# Note that the canvas isn't drawn until this line is run (even if the frame appears)
# All frame event handlers are started with this command, including controls
# A useful command is given for computing the width of the text in pixels
# Syntax: FRAME.get_canvas_textwidth("TEXT", font_size, "FONT FACE")
print myframe.get_canvas_textwidth("Hello", 12, "sans-serif")
# This returns "29", meaning that text in that font and size is 29 pixels wide
# "serif" (default), "sans-serif", and "monospace" are supported font faces
soundtrack.rewind()
soundtrack.set_volume(soundtrack_volume)
soundtrack.play()
def draw_lives(canvas):
'''draws the lives as mini-ship facing up like
the original Asteroids - NOTE: based on the
ImageInfo instance, not the Ship instance'''
[canvas.draw_image(ship_image, ship_info.get_center(), ship_info.get_size(),
[60 + life * 25, 70], (20, 20), math.pi * 1.5) \
for life in range(lives) if lives > 0]
# initialize frame
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
# initialize ship #Put this in a Class method()?
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], initial_ship_orientation(),
ship_image, ship_info)
# register handlers
frame.set_draw_handler(draw)
timer = simplegui.create_timer(1000.0, rock_spawner)
frame.set_keydown_handler(key_press)
frame.set_keyup_handler(key_release)
frame.set_mouseclick_handler(click)
# get things rolling
frame.start()
