def intro():
clear_screen("white")
# Draw red border
display.set_pen(255, 0, 0)
display.rectangle(1, 1, 238, 133)
display.set_pen(255, 255, 255)
display.rectangle(4, 4, 232, 127)
# Display "Pico"
pico_x_base = 30 # 93 works well for centre, 70 original
pico_y_base = 20
display.set_pen(0, 0, 0)
display.text("Pico", pico_x_base, pico_y_base, 0, 3)
# Display "F-Won"
logo_x_base = 30 ## 70 original
logo_y_base = 50
display.set_pen(255, 0, 0)
display.text("F-Won", logo_x_base, logo_y_base, 0, 4)
display.set_pen(0, 0, 0)
display.text("o", logo_x_base + 60, logo_y_base, 0, 4)
display.set_pen(255, 255, 255)
display.rectangle(logo_x_base + 76, logo_y_base + 4, 4, 4)
# Display "By CT"
name_x_base = 140 # 100 original
name_y_base = 100
display.set_pen(0, 0, 0)
display.text("By CT", name_x_base, name_y_base, 240, 3)
display.update()
utime.sleep(3)
def start(lap_delta, max_reaction_time):
# Draw the red start lights one at a time
clear_screen()
display.set_pen(255, 0, 0)
for light in range(5):
display.circle(40 + (light * 40), 50, 10)
display.update()
utime.sleep(1)
delay = math.fmod(utime.ticks_ms(), 4) + 1
utime.sleep(delay) # Random delay before go lights out
# Remove lights
display.set_pen(0, 0, 0)
display.rectangle(20, 35, 200, 30)
# No effect until next display.update()
# Click the correct side to "Go"
display.set_pen(0, 255, 0) # Green for GO
# display.circle(120, 50, 20)
# Pick side randomly for the start button, indicated by GO
side = random.choice(["<", ">"])
if side == "<":
display.text("G0", 20, 105, 240, 2)
else:
display.text("G0", 200, 105, 240, 2)
# Cover up start lights and display "Go"
display.update()
# Time the user's reaction
lap_delta += time_user(side, max_reaction_time)
return lap_delta
def time_user(side, max_reaction_time):
# Time user's reactions
t1 = utime.ticks_ms() # Start timer
while True:
utime.sleep_ms(1)
if ( (side == "<") and (display.is_pressed(display.BUTTON_B)) and (display.is_pressed(display.BUTTON_Y) == False) ) \
or ( (side == ">") and (display.is_pressed(display.BUTTON_Y)) and (display.is_pressed(display.BUTTON_B) == False) ):
t2 = utime.ticks_ms() # End timer
break
elif utime.ticks_diff(
utime.ticks_ms(),
t1) > max_reaction_time: # If 3 seconds has passed
t2 = utime.ticks_add(
t1, max_reaction_time
) # End timer, set to max time even if it's slightly passed 3 seconds
break
# Calculate reaction time and display results
reaction_time = utime.ticks_diff(t2, t1) / 1000
time_text = "T: " + "{:0<5}".format(
str(reaction_time)) # Display reaction time to 3 decimals (ms)
clear_screen()
display.set_pen(255, 255, 255)
display.text(time_text, 50, 30, 240, 4)
display.update()
utime.sleep_ms(750) # Pause to read reaction time
return reaction_time
def play():
count = 0
seq = []
while True:
seq.append(random.randint(0, 3))
for i in seq: # display the sequence
clearDisplay()
utime.sleep(0.5)
display.set_pen(rpen[i])
display.rectangle(rect[i]["x"], rect[i]["y"], rwidth, rheight)
display.update()
utime.sleep(sleep)
clearDisplay()
for i in seq: # get buttons for the sequence
b = getButton()
display.set_pen(rpen[b])
display.rectangle(rect[b]["x"], rect[b]["y"], rwidth, rheight)
display.update()
if b != i:
display.set_led(255, 0, 0)
utime.sleep(2)
display.set_led(0, 0, 0)
return len(seq) - 1
display.set_led(0, 255, 0)
utime.sleep(1)
display.set_led(0, 0, 0)
clearDisplay()
def clear_screen(background="black"):
if background == "white":
display.set_pen(255, 255, 255)
else:
display.set_pen(0, 0, 0)
display.clear()
display.update()
def update(self):
for y in range(0, height):
# We precompute the rows for a small performance gain.
row = y * width
# For each pixel in each row, we calculate the colours that will be
# rendered on the previous row, on the next call to update.
next_row = (y - 1) * width
for x in range(0, width):
color = self.fire[row + x]
pen = colorScale[color]
if y > 0:
new_x = x
# We're already at the first color index and can't move further.
if color > 0:
rand = random.randint(0, 3)
# Maybe move to the next colour.
color = color - (rand & 1)
# Spread the fire left and right.
new_x = new_x + rand - 1
self.fire[next_row + new_x] = color
display.set_pen(pen)
display.pixel(x, y)
display.update()
def flash_a():
picodisplay.set_pen(175, 175, 175)
picodisplay.clear()
picodisplay.set_pen(255, 255, 255)
picodisplay.text("Morning...", 5, 10, 240, 4)
picodisplay.set_pen(0, 0, 0)
picodisplay.text("Its monday!", 5, 50, 240, 5)
picodisplay.update()
def flash_b():
picodisplay.set_pen(100, 100, 100)
picodisplay.clear()
picodisplay.set_pen(255, 255, 255)
picodisplay.text("F#$%!", 5, 10, 240, 5)
picodisplay.set_pen(0, 0, 0)
picodisplay.text("Its monday!", 5, 50, 240, 5)
picodisplay.update()
def forward(self, distance):
oldx = self.x
oldy = self.y
self.x = self.x + int(
math.sin(self.heading * 2 * math.pi / 360) * distance)
self.y = self.y + int(
math.cos(self.heading * 2 * math.pi / 360) * distance)
self.line(oldy, oldx, self.y, self.x)
display.update()
def straight(lead_time):
clear_screen()
# Green circle for Go, straight-ahead until next turn
display.set_pen(0, 255, 0)
display.circle(120, 50, 20)
display.update()
# Leave straight-ahead on screen for the length of the straight
utime.sleep(lead_time)
# Clear screen, small pause for transistion
clear_screen()
utime.sleep_ms(1)
def menu():
display.set_led(0, 0, 0)
display.set_pen(BLACK)
display.clear()
display.set_pen(WHITE)
display.text("Press any button!", 10, 10, 240, (3, 6)[best == 0])
if best > 0:
display.text("Hiscore: " + str(best), 10, 68, 240, 3)
display.update() # Update the display
while True:
if display.is_pressed(display.BUTTON_A) or display.is_pressed(
display.BUTTON_B) or display.is_pressed(
display.BUTTON_X) or display.is_pressed(display.BUTTON_Y):
return
utime.sleep(0.5)
def menu(track_list):
clear_screen()
display.set_pen(255, 255, 255)
display.text("Select Track:", 20, 20, 240, 2)
track_selected = 0
max_tracks = len(track_list)
for track_num in range(max_tracks):
track_name = track_list[track_num][0]
track_text = (" " * 3) + track_name
display.text(track_text, 20, 40 + (20 * track_num), 240, 2)
display.set_pen(255, 255, 0)
display.text(">", 20, 40, 240, 2) # Track selector, initial position
display.set_pen(0, 255, 0)
display.text("Start Game", 115, 105, 240, 2)
display.update()
while True:
utime.sleep_ms(1)
track_change = False
display.set_pen(0, 0, 255)
if display.is_pressed(display.BUTTON_Y):
# Select current highlighted track
break
elif display.is_pressed(display.BUTTON_A):
# Up
track_selected = int(
math.fmod(track_selected + (max_tracks - 1), max_tracks))
track_change = True
utime.sleep_ms(250)
elif display.is_pressed(display.BUTTON_B):
# Down
track_selected = int(math.fmod(track_selected + 1, max_tracks))
track_change = True
utime.sleep_ms(250)
if track_change:
for track in range(max_tracks):
if track == track_selected:
display.set_pen(255, 255, 0)
display.text(">", 20, 40 + (20 * track), 240,
2) # Track selector
else:
display.set_pen(0, 0, 0)
display.text(">", 20, 40 + (20 * track), 240,
2) # Remove track selector
display.update()
track_change = False # Reset ready for next change
return track_selected
def game_loop(step_time, step_size):
# initialise objects
enemy_row = Row(start_y=0, number=5, colour={"r": 0, "g": 0, "b": 255})
player = Player(start_x=120,
start_y=110,
pixel_map=player_map,
colour={
"r": 255,
"g": 0,
"b": 0
})
enemy_row.update()
player.update()
# Loop
count = 0
projectiles = []
while True:
if display.is_pressed(display.BUTTON_Y):
player.dx += step_size
elif display.is_pressed(display.BUTTON_B):
player.dx -= step_size
elif display.is_pressed(display.BUTTON_X):
# fire projectile
projectiles.append(player.fire_projectile())
pass
elif display.is_pressed(display.BUTTON_A):
# reset game state/return and display final score?
clear_display()
return None
player.update()
# move enemy every 5 steps
if count % 5 == 0:
enemy_row.move(step_size)
if projectiles:
for projectile in projectiles:
projectile.move(step_size)
count = count + 1 if count < 256 else 0
display.update()
sleep(step_time)
def failed():
global best
display.set_pen(RED)
display.clear()
display.set_pen(YELLOW)
display.text("Game Over!", 10, 10, 240, 6) # Add some text
display.update() # Update the display
utime.sleep(1)
display.set_pen(RED)
display.clear()
display.set_pen(YELLOW)
display.text("Score: " + str(score), 10, 10, 240, 3)
if score > best:
display.text("New Hiscore!", 10, 68, 240, 3)
best = score
else:
display.text("Hiscore: " + str(best), 10, 68, 240, 3)
display.update() # Update the display
utime.sleep(3)
def next_turn(lap_delta, max_reaction_time, direction, lead_time):
clear_screen()
utime.sleep_ms(250) # Small pause for transition
straight(lead_time)
# Prepare large chevrons indicating turn direction
turn_text = direction * 3
display.set_pen(255, 255, 255)
display.text(turn_text, 100, 50, 240, 4)
# Prepare correct key, label with chevrons for the turn
display.set_pen(0, 255, 0)
if direction == "<":
display.text(turn_text, 20, 105, 240, 2)
else:
display.text(turn_text, 200, 105, 240, 2)
# Show the turn direction now
display.update()
# Time the user's reaction
lap_delta += time_user(direction, max_reaction_time)
return lap_delta
def run(self):
# Starting angle (unrotated in any dimension)
angleX, angleY, angleZ = 0, 0, 0
distance_delta = 0.1
while 1:
# It will hold transformed vertices.
t = []
for v in self.vertices:
# Rotate the point around X axis, then around Y axis, and finally around Z axis.
r = v.rotateX(angleX).rotateY(angleY).rotateZ(angleZ)
# Transform the point from 3D to 2D
p = r.project(*self.projection)
# Put the point in the list of transformed vertices
t.append(p)
display.set_pen(40, 40, 40)
display.clear()
display.set_pen(255, 255, 255)
for e in self.edges:
drawDDA(*to_int(t[e[0]].x, t[e[0]].y, t[e[1]].x, t[e[1]].y))
display.update()
# Continue the rotation
angleX += self.rotateX
angleY += self.rotateY
angleZ += self.rotateZ
self.projection[3] += distance_delta
if self.projection[3] > 12.0:
distance_delta = -0.1
if self.projection[3] < 2.0:
distance_delta = 0.1
def finish(lap_delta, time_to_line):
clear_screen()
straight(time_to_line)
# Draw chequered flag
display.set_pen(255, 255, 255)
display.rectangle(29, 19, 182, 102)
pen_white = True
rw = 20
rh = 20
for ry in range(20, 120, 20): # 20 to 100 in 20's
for rx in range(30, 210, 20): # 30 to 190 in 20's
if pen_white:
display.set_pen(0, 0, 0)
else:
display.set_pen(255, 255, 255)
pen_white = not (pen_white)
display.rectangle(rx, ry, rw, rh)
# Display the chequered flag for a few seconds
display.update()
utime.sleep(5)
# Show finish time
clear_screen()
display.set_pen(255, 255, 255)
display.text("Lap Delta:", 50, 20, 240, 3)
display.update()
display.set_pen(255, 0, 255)
time_text = "{:.3f}".format(
lap_delta) # Display reaction time to 3 decimals (ms)
display.text(time_text, 50, 50, 240, 4)
# Wait for key press to continue
display.set_pen(0, 255, 0)
display.text("Continue", 125, 105, 240, 2)
display.update()
while True:
utime.sleep_ms(1)
if display.is_pressed(display.BUTTON_Y):
break # Break loop to continue
return lap_delta
def clearDisplay():
display.set_pen(BLACK)
display.clear()
display.update()
def clear():
display.set_pen(0, 0, 0)
display.clear()
display.update()
def clear_display():
display.set_pen(BACKGROUND_COLOUR["r"], BACKGROUND_COLOUR["g"],
BACKGROUND_COLOUR["b"])
display.clear()
display.update()
def tick(self):
self.frame_skip = int(self.map_to_range(self.score, 0, 50, self.slow, self.fast))
if self.frameCount % self.frame_skip == 0:
self.update_inputs()
self.draw_background()
if self.state == self.game_state['playing']:
self.draw_game_objects()
self.snake.update_direction(self.pressed)
new_head = self.snake.move()
if new_head.pos == self.food.pos:
self.score += 1
self.snake.push(new_head)
self.food.reset_position(self.snake, self.level)
elif (self.snake.moving() and (self.snake.contains(new_head.pos) or self.level.check_walls(new_head.pos))):
self.cooldown = self.countdown
self.state = self.game_state['show_score']
else:
self.snake.push(new_head)
self.snake.pop()
else:
self.cooldown -= 1
self.show_game_text()
if self.cooldown < 0:
self.cooldown = self.countdown
if self.state == self.game_state['title_screen']:
self.lives_left = 3
self.level_number = 0
self.state = self.game_state['level_name']
elif self.state == self.game_state['level_name']:
self.init_level()
self.state = self.game_state['lives_left']
elif self.state == self.game_state['lives_left']:
self.state = self.game_state['playing']
elif self.state == self.game_state['show_score']:
if self.score > self.target_score:
self.level_number += 1
self.level_number %= self.total_levels
else:
self.lives_left -= 1
if self.lives_left == 0:
self.state = self.game_state['game_over']
else:
self.state = self.game_state['level_name']
elif self.state == self.game_state['game_over']:
self.state = self.game_state['title_screen']
display.update()
self.frameCount += 1
utime.sleep(self.base_refresh)
q = v * (1.0 - s * f)
t = v * (1.0 - s * (1.0 - f))
i = i % 6
if i == 0:
return v, t, p
if i == 1:
return q, v, p
if i == 2:
return p, v, t
if i == 3:
return p, q, v
if i == 4:
return t, p, v
if i == 5:
return v, p, q
h = 0
while True:
h += 1
r, g, b = [int(255 * c)
for c in hsv_to_rgb(h / 360.0, 1.0, 1.0)] # rainbow magic
display.set_led(r, g, b) # Set LED to a converted HSV value
display.set_pen(r, g, b) # Set pen to a converted HSV value
display.clear() # Fill the screen with the colour
display.set_pen(0, 0, 0) # Set pen to black
display.text("pico disco!", 10, 10, 240, 6) # Add some text
display.update() # Update the display
utime.sleep(1.0 / 60)
def run_game():
global key_mode, game_state
while True:
## Draw methods
display.set_pen(*SKY_COLOR)
display.clear()
ground.draw()
tank1.draw()
tank2.draw()
if (game_state == "player1fire" or game_state == "player2fire"):
shell.draw()
display.set_pen(*TEXT_COLOR)
if (game_state == "player1" or game_state == "player1fire"):
display.text("Player 1", 10, 10, 240, 1)
if (key_mode == "power"):
display.set_pen(*TEXT_COLOR_ACTIVE)
display.text("Power " + str(tank1.get_gun_power()) + "%", 10, 20,
240, 1) #
if (key_mode == "angle"):
display.set_pen(*TEXT_COLOR_ACTIVE)
else:
display.set_pen(*TEXT_COLOR)
display.text("Angle " + str(tank1.get_gun_angle()), 10, 30, 240, 1)
if (game_state == "player2" or game_state == "player2fire"):
display.text("Player 2", 180, 10, 240, 1)
if (key_mode == "power"):
display.set_pen(*TEXT_COLOR_ACTIVE)
display.text("Power " + str(tank2.get_gun_power()) + "%", 180, 20,
240, 1)
if (key_mode == "angle"):
display.set_pen(*TEXT_COLOR_ACTIVE)
else:
display.set_pen(*TEXT_COLOR)
display.text("Angle " + str(tank2.get_gun_angle()), 180, 30, 240,
1)
if (game_state == "game_over_1"):
display.text("Game Over", 50, 20, 240, 3)
display.text("Player 1 wins!", 30, 40, 240, 3)
if (game_state == "game_over_2"):
display.text("Game Over", 50, 20, 240, 3)
display.text("Player 2 wins!", 30, 40, 240, 3)
display.update()
## Update methods
# Only read keyboard in certain states
if (game_state == 'player1'):
player1_fired = player_keyboard("left")
if (player1_fired == True):
# Set shell position to end of gun
# Use gun_positions so we can get start position
gun_positions = tank1.calc_gun_positions()
start_shell_pos = (gun_positions[3][0],
gun_positions[3][1] + 2)
shell.set_start_position(start_shell_pos)
shell.set_current_position(start_shell_pos)
game_state = 'player1fire'
shell.set_angle(math.radians(tank1.get_gun_angle()))
shell.set_power(tank1.get_gun_power() / 40)
shell.set_time(0)
if (game_state == 'player1fire'):
shell.update_shell_position("left")
# shell value is whether the shell is inflight, hit or missed
shell_value = detect_hit("left")
# shell_value 20 is if other tank hit
if (shell_value >= 20):
game_state = 'game_over_1'
# 10 is offscreen and 11 is hit ground, both indicate missed
elif (shell_value >= 10):
# reset key mode to angle
key_mode = "angle"
game_state = 'player2'
if (game_state == 'player2'):
player2_fired = player_keyboard("right")
if (player2_fired == True):
# Set shell position to end of gun
# Use gun_positions so we can get start position
gun_positions = tank2.calc_gun_positions()
start_shell_pos = (gun_positions[3][0],
gun_positions[3][1] + 2)
shell.set_start_position(start_shell_pos)
shell.set_current_position(start_shell_pos)
game_state = 'player2fire'
shell.set_angle(math.radians(tank2.get_gun_angle()))
shell.set_power(tank2.get_gun_power() / 40)
shell.set_time(0)
if (game_state == 'player2fire'):
shell.update_shell_position("right")
# shell value is whether the shell is inflight, hit or missed
shell_value = detect_hit("right")
# shell_value 20 is if other tank hit
if (shell_value >= 20):
game_state = 'game_over_2'
# 10 is offscreen and 11 is hit ground, both indicate missed
elif (shell_value >= 10):
game_state = 'player1'
# reset key mode to angle
key_mode = "angle"
if (game_state == 'game_over_1' or game_state == 'game_over_2'):
# Allow space key or left-shift (picade) to continue
if (display.is_pressed(display.BUTTON_B)):
# Reset position of tanks and terrain
setup()
def tick(timer):
global display
display.update()
percentage = 100.00
# draw the battery outline
display.set_pen(0, 0, 0)
display.clear()
display.set_pen(190, 190, 190)
display.rectangle(0, 0, 220, 135)
display.rectangle(220, 40, 20, 55)
display.set_pen(0, 0, 0)
display.rectangle(3, 3, 214, 129)
# draw a green box for the battery level
display.set_pen(0, 255, 0)
display.rectangle(5, 5, round(210 / 100 * percentage), 125)
# add text
display.set_pen(255, 0, 0)
if charging.value() == 1: # if it's plugged into USB power...
display.text("Charging!", 15, 55, 240, 4)
else: # if not, display the battery stats
display.text('{:.2f}'.format(voltage) + "v", 15, 10, 240, 5)
display.text('{:.0f}%'.format(percentage), 15, 50, 240, 5)
# uncomment for low battery alarm (Pico Explorer only, you'll need to have GP0 and AUDIO connected with a jumper wire)
# display.set_audio_pin(0)
# if percentage < 5: # if the battery is less than 5%
# display.set_tone(262) # then make an annoying noise
display.update()
time.sleep(0.5)
# sets up a handy function we can call to clear the screen
def clear():
display.set_pen(0, 0, 0)
display.clear()
display.update()
while True:
if display.is_pressed(
display.BUTTON_A): # if a button press is detected then...
clear() # clear to black
display.set_pen(255, 255, 255) # change the pen colour
display.text("Button A pressed", 10, 10, 240,
4) # display some text on the screen
display.update() # update the display
utime.sleep(1) # pause for a sec
clear() # clear to black again
elif display.is_pressed(display.BUTTON_B):
clear()
display.set_pen(0, 255, 255)
display.text("Button B pressed", 10, 10, 240, 4)
display.update()
utime.sleep(1)
clear()
elif display.is_pressed(display.BUTTON_X):
clear()
display.set_pen(255, 0, 255)
display.text("Button X pressed", 10, 10, 240, 4)
display.update()
utime.sleep(1)
