def __init__(self, center, bound, pwm, controller: PlayerController,
player_turret: Turret, missile_turret: Turret,
life_turret: Turret):
super().__init__(center, bound, pwm)
'''
INIT PLAYER
'''
self.player_turret = player_turret
self.player = Player(bound, bound, pwm, player_turret, controller)
self.player.laser.on()
'''
INIT MISSILE
'''
self.missile_turret = missile_turret
self.missile = NPC(pwm, missile_turret)
self.missile.laser.on()
'''
INIT LIFE COUNTER
'''
self.life_turret = life_turret
self.life_counter = NPC(pwm, life_turret)
self.life_pos = int(center + bound / 2)
# Put life counter out of bounds
self.life_counter.set_servo(
int(center - bound / 2) - 10, int(center + bound / 2))
self.life_counter.laser.on()
self.life_distance = int(bound / self.lives)
class Maze(Game):
def __init__(
self,
center,
bound,
pwm,
controller: PlayerController,
player_turret: Turret,
):
super().__init__(center, bound, pwm)
self.player = Player(bound,
bound,
pwm,
player_turret,
controller,
initial_x=415,
initial_y=415,
x_center=375,
y_center=375)
self.player.laser.on()
def play_on(self):
self.playing = True
binding = {}
prev_time = 0
while self.playing:
curr_time = time.time()
if curr_time - prev_time >= self.time_rate:
prev_time = curr_time
x, y = self.player.manual_servo(**binding)
binding = WALLS.check_collision(x, y)
def prepare_game(board_file: str, players: List[discord.User],
channel: discord.TextChannel) -> MonopolyCore.Monopoly:
players_class = []
for player in players:
players_class.append(Player.Player(player))
board = Board.Board(board_file)
return MonopolyCore.Monopoly(monopoly_bot, channel, players_class, board)
def run(width, height, num_bombs):
pygame.init()
game = Game(width, height, num_bombs)
player = Player()
win = pygame.display.set_mode((width * 32, height * 32))
running = True
while running:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
running = False
pygame.quit()
quit()
player.update(events, game)
game.draw(win)
def test_add_cash(self):
p = Player.Player('0,0')
p.add_cash(100)
expected = 100
self.assertEqual(expected, p.get_cash())
p.add_cash(-1)
expected = 100
self.assertEqual(expected, p.get_cash())
def main():
game = Game()
ship_x = 330
ship_y = 500
ship_width = 32
ship_height = 32
player_ship = Player(ship_x, ship_y, ship_width, ship_height, ship)
game.init()
game.play(player_ship)
def __init__(
self,
center,
bound,
pwm,
controller: PlayerController,
player_turret: Turret,
):
super().__init__(center, bound, pwm)
self.player = Player(bound,
bound,
pwm,
player_turret,
controller,
initial_x=415,
initial_y=415,
x_center=375,
y_center=375)
self.player.laser.on()
def __init__(self, center, bound, pwm, player_1_controller,
player_2_controller, player_1_turret, player_2_turret,
npc_turret):
super().__init__(center, bound, pwm)
self.player_1 = Player(bound,
bound,
pwm,
player_1_turret,
player_1_controller,
no_x=True,
fixed_x=int(center + bound / 2))
self.player_2 = Player(bound,
bound,
pwm,
player_2_turret,
player_2_controller,
no_x=True,
fixed_x=int(center - bound / 2))
self.ball = NPC(pwm, npc_turret)
self.bounce = None
def test_use_cash(self):
p = Player.Player('100,0')
p.use_cash(101)
expected = 100
self.assertEqual(expected, p.get_cash())
p.use_cash(-1)
self.assertEqual(expected, p.get_cash())
p.use_cash(99)
expected = 1
self.assertEqual(expected, p.get_cash())
def test_determine_winner(self):
gameRunner = GameRunner.GameRunner()
dealer = Dealer.Dealer()
player = Player.Player(500)
dealer_cards = [('Clubs', '5'), ('Clubs', '6'), ('Clubs', 'Queen')]
player_cards = [('Clubs', '4'), ('Clubs', '5'), ('Clubs', 'Queen')]
dealer.cards = dealer_cards
player.cards = player_cards
gameRunner.determine_winner(dealer, player, 50)
def test_use_compost(self):
p = Player.Player('0,100')
p.use_compost(101)
expected = 100
self.assertEqual(expected, p.get_compost())
p.use_compost(-1)
self.assertEqual(expected, p.get_compost())
p.use_compost(99)
expected = 1
self.assertEqual(expected, p.get_compost())
def create_new_game():
global game_objects
game_objects = [
Player.Player("", create_new=True),
Apple.Apple("", create_new=True),
Beet.Beet("", create_new=True),
Carrot.Carrot("", create_new=True),
Grape.Grape("", create_new=True),
Pineapple.Pineapple("", create_new=True),
Potato.Potato("", create_new=True),
Rutabaga.Rutabaga("", create_new=True),
Watermelon.Watermelon("", create_new=True)
]
update_display_information()
display_game_frame()
def load_game():
global game_objects
with open(path.join(getcwd(), '..', 'txt-files', 'load_state'),
'r') as file:
data = file.read().split('\n')
game_objects = [
Player.Player(data[0]),
Apple.Apple(data[1]),
Beet.Beet(data[2]),
Carrot.Carrot(data[3]),
Grape.Grape(data[4]),
Pineapple.Pineapple(data[5]),
Potato.Potato(data[6]),
Rutabaga.Rutabaga(data[7]),
Watermelon.Watermelon(data[8])
]
update_display_information()
display_game_frame()
def testSettlementPieceAvailable(self):
"""
Test that settlement building function doesn't allow building if player doesn't have settlement pieces to build with
"""
# Create game
player_1 = Player(randomAction)
player_2 = Player(randomAction)
player_3 = Player(randomAction)
player_4 = Player(randomAction)
game_manager = GameManager([player_1, player_2, player_3, player_4])
game_manager.turn_counter = 7
# Give player 1 enough resources
player_1.resource_cards = [4] * 5
# Give player_1 0 settlement pieces
player_1.building_pieces[1] = 0
self.assertEqual(game_manager.buildSettlement(player_1, 5), False)
def testCorrectResources(self):
"""
Test that settlement building function doesn't allow building if player doesn't have enough resources
"""
# Create game
player_1 = Player(randomAction)
player_2 = Player(randomAction)
player_3 = Player(randomAction)
player_4 = Player(randomAction)
game_manager = GameManager([player_1, player_2, player_3, player_4])
game_manager.turn_counter = 7
# Give player 1 0 resources
player_1.resource_cards = [0] * 5
self.assertEqual(game_manager.buildSettlement(player_1, 5), False)
def testHasResources(self):
"""
Test hasResources function
"""
# Initialise player
player = Player(randomAction)
# Player with no resources requiring one of each type
self.assertEqual(player.hasResources([1, 1, 1, 1, 1]), False)
# Player with no resources requiring 4 resources
self.assertEqual(player.hasResources([1, 1, 1, 0, 1]), False)
# Player with enough resources
player.resource_cards = [2, 2, 2, 2, 2]
self.assertEqual(player.hasResources([1, 1, 1, 0, 1]), True)
def testOccupiedNode(self):
"""
Test that settlement building function doesn't allow building on already occupied node
"""
# Create game
player_1 = Player(randomAction)
player_2 = Player(randomAction)
player_3 = Player(randomAction)
player_4 = Player(randomAction)
game_manager = GameManager([player_1, player_2, player_3, player_4])
game_manager.turn_counter = 7
# Give player 1 enough resources for building settlement
player_1.resource_cards = [3] * 5
# 1st test another player with settlement on node 5
game_manager.game_board.nodes[5].settlement = [0, 1, 0, 0]
self.assertEqual(game_manager.buildSettlement(player_1, 5), False)
# 1st test another player with city on node 7
game_manager.game_board.nodes[7].city = [0, 1, 0, 0]
self.assertEqual(game_manager.buildSettlement(player_1, 7), False)
def main():
# CONSTANTS
IMAGE_SIZE = 100
settings = Settings() # Initialise settings object
SCREEN_WIDTH, SCREEN_HEIGHT = settings.width, settings.height
FLOOR_HEIGHT = SCREEN_HEIGHT * settings.floor_height_percentage
PLAYER_START_X = 0.25 * SCREEN_WIDTH
PLAYER_START_Y = FLOOR_HEIGHT
display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.init()
clock = pygame.time.Clock()
pygame.display.set_caption('Burrito Man')
event = Event() # Initialise the event handler
player = Player(PLAYER_START_X, PLAYER_START_Y,
FLOOR_HEIGHT) # Initialise the player
floor = Floor(display, SCREEN_WIDTH, SCREEN_HEIGHT, FLOOR_HEIGHT)
physics = Physics()
level = Level(display, SCREEN_WIDTH, SCREEN_HEIGHT,
settings.floor_height_percentage)
timer = Timer(display, GREEN, BLACK)
display.fill(BLACK)
# Generate obstacles
obstacle_list = level.generateObstacles(obstacle_num=4)
# Work out where the finish line should be (300px after last obstacle)
end_coord = level.createEnd(obstacle_list)
# Game loop
while True:
display.fill(BLACK)
event.update(pygame.event.get(), player, obstacle_list)
pygame.draw.rect(display, RED, player.rect)
# display.blit(player.image, player.rect) # draw player
floor.draw()
timer.render(100, 100, pygame.time.get_ticks())
# draw all Obstacles in obstacle_list
for obst in obstacle_list:
# Draw the finish line as a vertical white line
level.drawFinish(end_coord, player.world_scroll)
obst.update(player.world_scroll)
obst.draw()
player.vertical_a = physics.calculate_vertical_acceleration(
player, floor)
player.vertical_velocity = physics.calculate_vertical_velocity(
player, floor)
# Update player y position
player.rect.y = player.y + player.vertical_velocity
if player.jumpAttempt is True:
player.jump()
# player.jump_animation()
pygame.display.update()
clock.tick(60) # opt arg: limit framerate; otherwise, unlimited
print("\n###Debugging###")
debug_statements(
{
"msg": "FPS",
"args": round(clock.get_fps())
},
{
"msg": "World scroll",
"args": player.world_scroll
},
{
"msg": "Distance to finish",
"args": round(end_coord[0] - player.world_scroll - 250, 2)
},
{
"msg": "Player touching floor",
"args": physics.on_obj(player, floor)
},
{
"msg": "Vertical acceleration of player",
"args": round(player.vertical_a, 2)
},
{
"msg": "Vertical velocity of player",
"args": round(player.vertical_velocity, 2)
},
)
class Pong(Game):
"""
Two players swat a ball back and forth.
"""
'''
PLAYER INFO
'''
paddle_length = 15
'''
BALL INFO
'''
ball_rate = 2
resetting = False
skip_frame = False
laser_blink = False
reset_time = 0
reset_rate = 1
'''
GAME INFO
'''
win_points = 10
def __init__(self, center, bound, pwm, player_1_controller,
player_2_controller, player_1_turret, player_2_turret,
npc_turret):
super().__init__(center, bound, pwm)
self.player_1_turret = player_1_turret
self.player_2_turret = player_2_turret
self.npc_turret = npc_turret
self.player_1 = Player(bound,
bound,
pwm,
player_1_turret,
player_1_controller,
no_x=True,
fixed_x=int(center + bound / 2))
self.player_2 = Player(bound,
bound,
pwm,
player_2_turret,
player_2_controller,
no_x=True,
fixed_x=int(center - bound / 2))
self.ball = NPC(pwm, npc_turret)
self.bounce = None
def play_on(self):
player_1_points = 0
player_2_points = 0
self.playing = True
self.ball.laser.on()
self.player_1.laser.on()
self.player_2.laser.on()
# vertical_hit = False
# horizontal_hit = False
while self.playing:
if player_1_points == self.win_points:
self.win(1)
elif player_2_points == self.win_points:
self.win(2)
# pi/2 cone facing either player
if random.randint(0, 1):
angle = random.uniform(-0.785, 0.785)
else:
angle = random.uniform(2.355, 3.925)
ball = self.make_ball(rate=self.ball_rate, angle=angle)
prev_time = 0
while self.playing:
self.curr_time = time.time()
if self.curr_time - prev_time >= self.time_rate:
if not self.resetting:
xs, ys = ball.__next__()
else:
xs = self.center
ys = self.center
prev_time = self.curr_time
x_1, y_1 = self.player_1.set_servo()
x_2, y_2 = self.player_2.set_servo()
x_1_hit = xs > 415
x_2_hit = xs < 320
y_1_hit = fabs(y_1 - ys) <= self.paddle_length
y_2_hit = fabs(y_2 - ys) <= self.paddle_length
# Player 1 or 2 lose
if not y_1_hit and x_1_hit:
player_2_points += 1
self.resetting = True
self.reset_time = time.time()
break
elif not y_2_hit and x_2_hit:
player_1_points += 1
self.resetting = True
self.reset_time = time.time()
break
else:
top_hit = ys >= (self.center + self.bound / 2)
bottom_hit = ys <= (self.center - self.bound / 2)
# Player hit
if (y_1_hit and x_1_hit) or (y_2_hit and x_2_hit):
self.bounce.vertical_hit(random_bounce=True)
self.bounce.rate += 0.1
# Top or bottom wall hit
elif top_hit or bottom_hit:
self.bounce.horizontal_hit()
self.handle_ball_resetting()
def handle_ball_resetting(self):
"""
Handles all player info after firing, such as laser blinking
:return:
"""
if self.resetting:
if not self.skip_frame:
self.skip_frame = True
if self.laser_blink:
self.ball.laser.on()
else:
self.ball.laser.off()
self.laser_blink = not self.laser_blink
else:
self.skip_frame = False
if self.curr_time - self.reset_time > self.reset_rate:
self.resetting = False
self.ball.laser.on()
def make_ball(self, angle=2, rate=2):
self.bounce = Bounce(self.center, self.center, angle, rate)
ball_servo = self.ball.follow_path(self.bounce.data())
# Let the servos get into position. Yes, yield twice
ball_servo.__next__()
ball_servo.__next__()
return ball_servo
def win(self, player):
if player == 1:
del self.player_1.laser
center = int(self.center + self.bound / 2)
npc = NPC(self.pwm, self.player_1_turret)
else:
del self.player_2.laser
center = int(self.center - self.bound / 2)
npc = NPC(self.pwm, self.player_2_turret)
circle = Circle(center, 375, 25, 0, 2)
data = npc.follow_path(circle.data())
data.__next__()
data.__next__()
npc.laser.on()
spin_spin = 0
prev_time = 0
while self.playing:
self.curr_time = time.time()
if self.curr_time - prev_time >= self.time_rate * 3:
prev_time = self.curr_time
data.__next__()
spin_spin += 1
if spin_spin == 100:
self.playing = False
def main():
global player
player = Player.Player(db.connection, '/app/src/music')
def initializeGame(): #Incase you want to initialize more than the player at startup
mainGuy = Player.Player(1000, 200, 10, 10,[])
return mainGuy
import time from src.GameManager import * from src.Player import * player_1 = Player(randomAction) player_2 = Player(randomAction) player_3 = Player(randomAction) player_4 = Player(randomAction) game_manager = GameManager([player_1, player_2, player_3, player_4]) start_time = time.time() game_manager.startGame() end_time = time.time() print(end_time - start_time)
def test_analyze_response_hit_response(self):
dealer = self.dealer
player = Player('George')
player.response = 'hit'
response = dealer.analyze_response(player)
self.assertIsInstance(response, Card)
def test_analyze_response_stay_response(self):
dealer = self.dealer
player = Player('George')
player.response = 'stay'
response = dealer.analyze_response(player)
self.assertIsNone(response)
class Pong(Game):
"""
Two players swat a ball back and forth.
"""
'''
PLAYER INFO
'''
paddle_length = 10
x_hit = 0
'''
BALL INFO
'''
ball_rate = 2
resetting = False
skip_frame = False
laser_blink = False
reset_time = 0
reset_rate = 1
def __init__(self, center, bound, pwm, player_1_controller,
player_2_controller, player_1_turret, player_2_turret,
npc_turret):
super().__init__(center, bound, pwm)
self.player_1 = Player(bound,
bound,
pwm,
player_1_turret,
player_1_controller,
no_x=True,
fixed_x=int(center + bound / 2))
self.player_2 = Player(bound,
bound,
pwm,
player_2_turret,
player_2_controller,
no_x=True,
fixed_x=int(center - bound / 2))
self.ball = NPC(pwm, npc_turret)
self.bounce = None
def play_on(self):
player_1_points = 0
player_2_points = 0
self.playing = True
self.ball.laser.on()
self.player_1.laser.on()
self.player_2.laser.on()
# vertical_hit = False
# horizontal_hit = False
while self.playing:
ball = self.make_ball(self.ball_rate)
prev_time = 0
# xs, ys = ball.send((horizontal_hit, vertical_hit))
while self.playing:
self.curr_time = time.time()
if self.curr_time - prev_time >= self.time_rate:
if not self.resetting:
# xs, ys = ball.send((horizontal_hit, vertical_hit))
xs, ys = ball.__next__()
else:
xs = self.center
ys = self.center
prev_time = self.curr_time
x_1, y_1 = self.player_1.set_servo()
x_2, y_2 = self.player_2.set_servo()
x_1_hit = fabs(x_1 - xs) <= self.x_hit
x_2_hit = fabs(x_2 - xs) <= self.x_hit
y_1_hit = fabs(y_1 - ys) <= self.paddle_length
y_2_hit = fabs(y_2 - ys) <= self.paddle_length
# Player 1 or 2 lose
if not y_1_hit and x_1_hit:
player_2_points += 1
self.resetting = True
self.reset_time = time.time()
break
elif not y_2_hit and x_2_hit:
player_1_points += 1
self.resetting = True
self.reset_time = time.time()
break
else:
top_hit = ys >= (self.center + self.bound / 2)
bottom_hit = ys <= (self.center - self.bound / 2)
# Player hit
if (y_1_hit and x_1_hit) or (y_2_hit and x_2_hit):
# vertical_hit = True
self.bounce.vertical_hit()
# horizontal_hit = False
self.bounce.rate += 0.1
# Top or bottom wall hit
elif top_hit or bottom_hit:
# vertical_hit = False
# horizontal_hit = True
self.bounce.horizontal_hit()
# else:
# vertical_hit = False
# horizontal_hit = False
# if not self.resetting:
# xs, ys = ball.send((horizontal_hit,
# vertical_hit))
self.handle_ball_resetting()
def handle_ball_resetting(self):
"""
Handles all player info after firing, such as laser blinking
:return:
"""
if self.resetting:
if not self.skip_frame:
self.skip_frame = True
if self.laser_blink:
self.ball.laser.on()
else:
self.ball.laser.off()
self.laser_blink = not self.laser_blink
else:
self.skip_frame = False
if self.curr_time - self.reset_time > self.reset_rate:
self.resetting = False
self.ball.laser.on()
def make_ball(self, angle=2, rate=2):
self.bounce = Bounce(self.center, self.center, angle, rate)
ball_servo = self.ball.follow_path(self.bounce.data())
# Let the servos get into position. Yes, yield twice
ball_servo.__next__()
ball_servo.send((False, False))
return ball_servo
from src.Player import *
from src.Deck import Deck
from src.Game import Game
print('\n' * 10)
print('Welcome to the Casino Royale\'s high roller blackjack table, '
'please enter your starting chip amount!')
try:
chips = int(input('Chips: '))
except ValueError:
print('You have crashed the game bad boy')
exit(1)
my_player = Player(chips, [], 0)
my_deck = Deck()
my_dealer = Dealer([])
game = Game()
who = 0
play_again = True
game_options = {
1: 'Raise Bet',
2: 'Hit me',
3: 'Stop',
4: 'Check_hand',
5: 'Check total chips',
6: 'Cash out'
}
while play_again:
class Maze(Game):
"""
Find your way to the end!
"""
'''
GAME INFO
'''
# TOUCHDOWN
endzone = [[0, 16], [0, 16]]
lose_time = 360
def __init__(
self,
center,
bound,
pwm,
controller: PlayerController,
player_turret: Turret,
):
super().__init__(center, bound, pwm)
self.player_turret = player_turret
self.player = Player(bound,
bound,
pwm,
player_turret,
controller,
initial_x=415,
initial_y=415,
x_center=375,
y_center=375)
self.player.laser.on()
def play_on(self):
self.playing = True
binding = {}
prev_time = 0
start_time = time.time()
while self.playing:
curr_time = time.time()
if curr_time - prev_time >= self.time_rate:
prev_time = curr_time
x, y = self.player.manual_servo(**binding)
binding = WALLS.check_collision(x, y)
centered_x = x - self.center + self.bound / 2
centered_y = y - self.center + self.bound / 2
# Check if the player scored the winning goal!!!
if self.endzone[0][0] <= centered_x <= self.endzone[0][1] and \
self.endzone[1][0] <= centered_y <= self.endzone[1][1]:
self.win()
self.playing = False
if curr_time - start_time >= self.lose_time:
self.playing = False
def win(self):
# Free up the GPIO pin
del self.player.laser
npc = NPC(self.pwm, self.player_turret)
radius = 20
rate = 0.1
circle = Circle(375, 375, radius, 0, rate)
data = npc.follow_path(circle.data())
data.__next__()
data.__next__()
npc.laser.on()
for _ in range(0, 600):
if _ % 100 == 0:
circle.clockwise = False
data.__next__()
class MissileDefense(Game):
"""
The player must aim and shoot at missile raining down on a peaceful city.
"""
'''
GAME INFO
'''
curr_time = 0
'''
PLAYER INFO
'''
# Delay until the player can fire again
player_attack_rate = 1
# Size of player attack
bomb_radius = 10
player_fired = False
fire_time = 0
skip_frame = False
laser_blink = False
'''
MISSILE INFO
'''
# How long to delay until the missile comes alive
missile_delay = 1
# How much to increase the missile speed per success
rate_increase = 0.1
'''
LIVES INFO
'''
lives = 10
life_pos = 0
def __init__(self, center, bound, pwm, controller: PlayerController,
player_turret: Turret, missile_turret: Turret,
life_turret: Turret):
super().__init__(center, bound, pwm)
'''
INIT PLAYER
'''
self.player = Player(bound, bound, pwm, player_turret, controller)
self.player.laser.on()
'''
INIT MISSILE
'''
self.missile = NPC(pwm, missile_turret)
self.missile.laser.on()
'''
INIT LIFE COUNTER
'''
self.life_counter = NPC(pwm, life_turret)
self.life_pos = int(center + bound / 2)
# Put life counter out of bounds
self.life_counter.set_servo(
int(center - bound / 2) - 10, int(center + bound / 2))
self.life_counter.laser.on()
self.life_distance = int(bound / self.lives)
def play_on(self):
self.playing = True
hit = False
lose = False
prev_time = 0
player_score = 0
missile_rate = 1
missile = self.make_missile()
missile_respawn = False
respawn_time = time.time()
while self.playing:
if hit:
player_score += 1
missile_rate += self.rate_increase
if lose:
self.lives -= 1
self.life_pos -= self.life_distance
self.life_counter.set_servo(
int(self.center - self.bound / 2) - 10, self.life_pos)
if hit or lose:
hit = False
lose = False
self.missile.laser.off()
missile = self.make_missile(missile_rate)
missile_respawn = True
respawn_time = time.time()
# Win/lose conditions
if player_score == 10:
pass
elif self.lives == 0:
pass
self.curr_time = time.time()
if self.curr_time - prev_time >= self.time_rate:
prev_time = self.curr_time
p_x, p_y = self.player.set_servo()
if not missile_respawn:
try:
m_x, m_y = missile.__next__()
except StopIteration:
lose = True
else:
if not self.player_fired and self.player.firing():
self.player_fired = True
self.fire_time = time.time()
dist_2_bomb = sqrt((m_y - p_y)**2 + (m_x - p_x)**2)
if dist_2_bomb <= self.bomb_radius:
hit = True
else:
if self.curr_time - respawn_time > self.missile_delay:
missile_respawn = False
self.missile.laser.on()
self.handle_player_firing()
def handle_player_firing(self):
"""
Handles all player info after firing, such as laser blinking
:return:
"""
if self.player_fired:
if not self.skip_frame:
self.skip_frame = True
if self.laser_blink:
self.player.laser.on()
else:
self.player.laser.off()
self.laser_blink = not self.laser_blink
else:
self.skip_frame = False
if self.curr_time - self.fire_time > self.player_attack_rate:
self.player_fired = False
self.player.laser.on()
def make_missile(self, rate=1) -> Generator:
"""
Creates a new random missile
:param rate:
:return:
"""
y_low = int(self.center - self.bound / 2)
y_high = int(self.center + self.bound / 2)
x_start = random.randint(y_low, y_high)
# Since the controllers can't reach the corners, restrict them
x_end = random.randint(y_low + 20, y_high - 20)
path = Line(x_start, y_high, x_end, y_low, rate)
missile = self.missile.follow_path(path.data())
# Let the servos get into position. Yield once for init, yield again to move servos
missile.__next__()
missile.__next__()
return missile
class MissileDefense(Game):
"""
The player must aim and shoot at missile raining down on a peaceful city.
"""
'''
GAME INFO
'''
curr_time = 0
num_missiles = 20
'''
PLAYER INFO
'''
# Delay until the player can fire again
player_attack_rate = 1
# Size of player attack
bomb_radius = 15
player_fired = False
fire_time = 0
skip_frame = False
laser_blink = False
'''
MISSILE INFO
'''
# How long to delay until the missile comes alive
missile_delay = 1
# How much to increase the missile speed per success
rate_increase = 0.1
'''
LIVES INFO
'''
lives = 10
life_pos = 0
def __init__(self, center, bound, pwm, controller: PlayerController,
player_turret: Turret, missile_turret: Turret,
life_turret: Turret):
super().__init__(center, bound, pwm)
'''
INIT PLAYER
'''
self.player_turret = player_turret
self.player = Player(bound, bound, pwm, player_turret, controller)
self.player.laser.on()
'''
INIT MISSILE
'''
self.missile_turret = missile_turret
self.missile = NPC(pwm, missile_turret)
self.missile.laser.on()
'''
INIT LIFE COUNTER
'''
self.life_turret = life_turret
self.life_counter = NPC(pwm, life_turret)
self.life_pos = int(center + bound / 2)
# Put life counter out of bounds
self.life_counter.set_servo(
int(center - bound / 2) - 10, int(center + bound / 2))
self.life_counter.laser.on()
self.life_distance = int(bound / self.lives)
def play_on(self):
self.playing = True
hit = False
lose = False
prev_time = 0
missile_rate = 1
missile = self.make_missile()
missile_respawn = False
respawn_time = time.time()
while self.playing:
if hit:
missile_rate += self.rate_increase
elif lose:
self.lives -= 1
self.life_pos -= self.life_distance
self.life_counter.set_servo(
int(self.center - self.bound / 2) - 10, self.life_pos)
if hit or lose:
self.num_missiles -= 1
hit = False
lose = False
self.missile.laser.off()
missile = self.make_missile(missile_rate)
missile_respawn = True
respawn_time = time.time()
# Win/lose conditions. Check lose first in case of lives=missiles=0
if self.lives == 0:
self.lose()
break
elif self.num_missiles == 0:
self.win()
break
self.curr_time = time.time()
if self.curr_time - prev_time >= self.time_rate:
prev_time = self.curr_time
p_x, p_y = self.player.set_servo()
if not missile_respawn:
try:
m_x, m_y = missile.__next__()
except StopIteration:
lose = True
else:
if not self.player_fired and self.player.firing():
self.player_fired = True
self.fire_time = time.time()
dist_2_bomb = sqrt((m_y - p_y)**2 + (m_x - p_x)**2)
if dist_2_bomb <= self.bomb_radius:
hit = True
else:
if self.curr_time - respawn_time > self.missile_delay:
missile_respawn = False
self.missile.laser.on()
self.handle_player_firing()
def handle_player_firing(self):
"""
Handles all player info after firing, such as laser blinking
:return:
"""
if self.player_fired:
if not self.skip_frame:
self.skip_frame = True
if self.laser_blink:
self.player.laser.on()
else:
self.player.laser.off()
self.laser_blink = not self.laser_blink
else:
self.skip_frame = False
if self.curr_time - self.fire_time > self.player_attack_rate:
self.player_fired = False
self.player.laser.on()
def make_missile(self, rate=1, npc: NPC = None) -> Generator:
"""
Creates a new random missile
:param rate:
:param npc:
:return:
"""
y_low = int(self.center - self.bound / 2)
y_high = int(self.center + self.bound / 2)
x_start = random.randint(y_low, y_high)
# Since the controllers can't reach the corners, restrict them
x_end = random.randint(y_low + 15, y_high - 15)
if self.num_missiles > 5:
path = Line(x_start, y_high, x_end, y_low, rate)
else:
# Last five missiles get cray-cray
path = Corkscrew(x_start, y_high, x_end, y_low, 10, 0, 1, rate)
if npc is None:
missile = self.missile.follow_path(path.data())
else:
missile = npc.follow_path(path.data())
# Let the servos get into position. Yield once for init, yield again to move servos
missile.__next__()
missile.__next__()
return missile
def win(self):
"""
"We're in the endgame now" - Wizard guy.
:return:
"""
# Free up the GPIO pin
del self.player.laser
del self.missile.laser
del self.life_counter.laser
npc1 = NPC(self.pwm, self.player_turret)
npc2 = NPC(self.pwm, self.missile_turret)
npc3 = NPC(self.pwm, self.life_turret)
radius = 20
rate = 0.1
circle1 = Circle(415, 375, radius, 0, rate)
circle2 = Circle(375, 375, radius, 0, rate)
circle3 = Circle(335, 375, radius, 0, rate, clockwise=False)
data1 = npc1.follow_path(circle1.data())
data1.__next__()
data1.__next__()
npc1.laser.on()
data2 = npc2.follow_path(circle2.data())
data2.__next__()
data2.__next__()
npc2.laser.on()
data3 = npc3.follow_path(circle3.data())
data3.__next__()
data3.__next__()
npc3.laser.on()
for _ in range(0, 400):
if _ % 100 == 0:
circle3.clockwise = False
data1.__next__()
data2.__next__()
data3.__next__()
def lose(self):
"""
"Did we just lose?" - Sun-Count.
:return:
"""
# Free up the GPIO pin
del self.player.laser
del self.missile.laser
del self.life_counter.laser
npc1 = NPC(self.pwm, self.player_turret)
npc2 = NPC(self.pwm, self.missile_turret)
npc3 = NPC(self.pwm, self.life_turret)
npc1.laser.on()
npc2.laser.on()
npc3.laser.on()
rate = 2
m1 = self.make_missile(rate, npc1)
m2 = self.make_missile(rate, npc2)
m3 = self.make_missile(rate, npc3)
prev_time = 0
num_losers = 15
while True:
if num_losers == 0:
break
self.curr_time = time.time()
if self.curr_time - prev_time >= self.time_rate:
prev_time = self.curr_time
try:
m1.__next__()
except StopIteration:
m1 = self.make_missile(rate, npc1)
num_losers -= 1
try:
m2.__next__()
except StopIteration:
m2 = self.make_missile(rate, npc2)
num_losers -= 1
try:
m3.__next__()
except StopIteration:
m3 = self.make_missile(rate, npc3)
num_losers -= 1
