def addPowerup(self):
x_point = 300 + random.randint(-250, 250)
new_powerup = Powerup(self.powerup_width, self.powerup_height, x_point,
0, self.powerup_color)
self.powerups.append(new_powerup)
print("upgrade")
return
def spawn_enemies(self):
spawns = self.level.get_spawns()
if spawns[Level.SHARKS]:
# Make a new shark
self.sharks.append(Shark())
self.shark_sprites.add(self.sharks[-1])
if spawns[Level.PIRATES]:
# Make a new pirate ship
self.pirates.append(Pirateboat())
self.pirate_sprites.add(self.pirates[-1])
if spawns[Level.MINES]:
self.mines.append(Mine())
self.mine_sprites.add(self.mines[-1])
if spawns[Level.SEAGULLS]:
self.seagulls.append(Seagull())
self.seagull_sprites.add(self.seagulls[-1])
if spawns[Level.TITANIC]:
self.titanic = Titanic()
self.titanic_sprite.add(self.titanic)
if spawns[Level.POWERUPS]:
self.powerups.append(Powerup())
self.powerup_sprites.add(self.powerups[-1])
def create_powerup():
ids = [0, 1, 2]
powerup_id = random.choice(ids)
x_set = range(0, width - powerup_width)
y_set = range(-110, -90)
# (x, y) = (random.choice(x_set), random.choice(y_set))
(x, y) = get_block_pos()
powerup = Powerup(powerup_id, powerup_width, powerup_height, x, y)
powerup_group.add(powerup)
def create_powerup(ai_settings, screen, powerups, images):
number_powerup_x = ai_settings.powerup_allowed
for powerup_amount in range(number_powerup_x):
if len(powerups) < number_powerup_x:
if ai_settings.frame_count / 60 >= ai_settings.powerup_cooldown:
powerup = Powerup(ai_settings, screen, images)
powerups.add(powerup)
print("powerup spawned")
ai_settings.powerup_cooldown += ai_settings.powerup_increase
def __init__(self):
(w,h) = (800,800)
pygame.init()
pygame.display.set_mode((w,h), 0, 32)
self.screen = pygame.display.get_surface()
self.player = Player(self.screen.get_rect())
self.player_list = [self.player]
self.enemy = Enemy(400,100)
self.enemy_list = [self.enemy]
self.respawn = False
self.respawn_time = time.time()
self.power_up = Powerup(self.screen)
def decode_powerup_data(msg):
decoded = []
powdict = {} # A single item will look like id:[x, y, type]
for att in msg[1:]:
att = att.split("/")
idd = att[
0] # an id is used for each attribute so the order of the list doesnt matter
powdict.setdefault(idd, [0, 0, 0])
if att[1][0] == "x":
powdict[idd][0] = int(att[1][1:])
if att[1][0] == "y":
powdict[idd][1] = int(att[1][1:])
if att[1][0] == "t":
powdict[idd][2] = int(att[1][1:])
for po in powdict.values():
decoded.append(Powerup(po[0], po[1], po[2]))
return decoded
def __init__(self, **kw):
super(RootWidget, self).__init__(**kw)
self.level = 1
self.seconds = 0
self.combo = 1
self.score = 0
self.hits = 0
self.cons = 0
self.rainboxes = [Rainbox(pos=(-500, 0)) for i in range(10)]
self.powerup = Powerup()
self.miniball = Rainball(size=(60, 60), name='mini')
self.miniball.speed = 20
self.maxiball = Rainball(size=(120, 120), name='maxi', element='stone')
self.background = Background(size=Window.size)
self.target_l = Image(source='img/target_l.zip', size=(60, 60))
self.lbl_fps = Label(pos=(Window.width - 100, 0))
self.lbl_level = PopLabel(pos=(100, Window.height - 100),
font_name='font/Mouser.ttf')
self.lbl_hits = PopLabel(pos=(100, Window.height - 140),
font_name='font/Mouser.ttf')
self.lbl_combo = PopLabel(pos=(100, Window.height - 180),
font_name='font/Mouser.ttf')
self.lbl_score = PopLabel(pos=(100, Window.height - 220),
font_name='font/Mouser.ttf')
self.add_widget(self.background, canvas='before')
self.add_widget(self.target_l)
self.add_widget(self.miniball)
self.add_widget(self.maxiball)
self.add_widget(self.lbl_fps)
self.add_widget(self.lbl_level)
self.add_widget(self.lbl_hits)
self.add_widget(self.lbl_combo)
self.add_widget(self.lbl_score)
self.add_widget(self.powerup)
for i in range(10):
self.add_widget(self.rainboxes[i])
self._keyboard = Window.request_keyboard(self._keyboard_closed, self,
'text')
self._keyboard.bind(on_key_down=self._on_key_down)
sounds['music'].loop = True
sounds['music'].play()
Clock.schedule_interval(self.update, 1 / 60.)
def __init__(self):
pyxel.init(240, 240, caption='Bourne Again', fps=30)
pyxel.mouse(True)
pyxel.load('stuff.pyxres')
self.seemsg = ''
self.seemsg_iter = ''
self.seemsg_out = ''
self.player = Player(30, 120)
self.beam_angle = None
self.inputed_angle = None
self.beam_start_time = 0
#self.wll_index = 0
self.targets = {
'A': Target(200, 120, 'Target A feels lonely'),
'B': Target(1, 20, 'Fortune awaits Target B'),
'C': Target(120, 199, 'Target C is in the mood for shawarma')
}
self.walls = [Solid(150, 120), Solid(100, 45), Solid(24, 200)]
self.flag = Flag(60, 24)
self.powerup = Powerup(80, 120)
self.upgraded = False
self.blocked_functions = ['up', 'down', 'left']
self.locked = False
self.has_won = False
self.raycast_distance = 0
self.raycast_has_collided = False
pyxel.playm(1, loop=True)
pyxel.run(self.update, self.draw)
def __init__(self,
rows=30,
cols=1000,
start_x=23,
start_y=17,
boss_x=950,
boss_y=5):
self._score = 0
self._coins = 0
self._board = Board(rows, cols)
self._hero = Mandalorian(start_x, start_y)
self._boss = Enemy(boss_x, boss_y)
self._getch = getInput._getChUnix()
self._rem_time = 100
self._fired_bullets = []
self._thrown_snowballs = []
self._coins_placed = []
self._zappers = []
self._speedup = False
self._magnet = Magnet(0, 0)
self._powerup = Powerup(0, 0)
self._speedup = False
self._ground = Ground()
def run_game(self):
game_over = True
running = True
while running:
if game_over:
self.show_go_screen()
game_over = False
self.all_sprites = pygame.sprite.Group()
self.mobs = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.powerups = pygame.sprite.Group()
self.player = Player(self.settings, self.graphics_provider,
self.sound_provider, self.bullets,
self.all_sprites)
self.all_sprites.add(self.player)
for i in range(8):
self.new_mob()
for i in range(3):
self.new_enemy()
score = 0
# keep loop running at the right speed
self.clock.tick(self.settings.FPS)
# Process input (events)
for event in pygame.event.get():
# check for closing window
if event.type == pygame.QUIT:
running = False
# Update
self.all_sprites.update()
# check to see if a bullet hit a mob
hits = pygame.sprite.groupcollide(self.mobs, self.bullets, True,
True)
for hit in hits:
score += 50 - hit.radius
random.choice(self.sound_provider.expl_sounds).play()
expl = Explosion(hit.rect.center, 'large',
self.graphics_provider)
self.all_sprites.add(expl)
if random.random() > 0.9:
powerup = Powerup(hit.rect.center, self.settings,
self.graphics_provider)
self.all_sprites.add(powerup)
self.powerups.add(powerup)
self.new_mob()
# check to see if a bullet hit an enemy
hits = pygame.sprite.groupcollide(self.enemies, self.bullets, True,
True)
for hit in hits:
score += 50 - hit.radius
random.choice(self.sound_provider.expl_sounds).play()
expl = Explosion(hit.rect.center, 'large',
self.graphics_provider)
self.all_sprites.add(expl)
if random.random() > 0.9:
powerup = Powerup(hit.rect.center, self.settings,
self.graphics_provider)
self.all_sprites.add(powerup)
self.powerups.add(powerup)
self.new_enemy()
# check to see if a mob hit the player
hits = pygame.sprite.spritecollide(self.player, self.mobs, True,
pygame.sprite.collide_circle)
for hit in hits:
self.player.shield -= hit.radius * 2
expl = Explosion(hit.rect.center, 'small',
self.graphics_provider)
self.all_sprites.add(expl)
self.new_mob()
if self.player.shield <= 0:
self.sound_provider.player_die_sound.play()
death_explosion = Explosion(self.player.rect.center,
'player',
self.graphics_provider)
self.all_sprites.add(death_explosion)
self.player.hide()
self.player.lives -= 1
self.player.shield = 100
# check to see if player hit a powerup
hits = pygame.sprite.spritecollide(self.player, self.powerups,
True)
for hit in hits:
if hit.type == 'shield':
self.player.shield += random.randrange(10, 30)
self.sound_provider.shield_sound.play()
if self.player.shield >= 100:
self.player.shield = 100
if hit.type == 'gun':
self.player.powerup()
self.sound_provider.power_sound.play()
# if the player died and the explosion has finished playing
if self.player.lives == 0 and not death_explosion.alive():
game_over = True
# Draw / render
self.screen.fill(self.settings.colors.black)
self.screen.blit(self.graphics_provider.background,
self.graphics_provider.background_rect)
self.all_sprites.draw(self.screen)
self.draw_text(self.screen, str(score), 18,
self.settings.WIDTH / 2, 10)
self.draw_shield_bar(self.screen, 5, 5, self.player.shield)
self.draw_lives(self.screen, self.settings.WIDTH - 100, 5,
self.player.lives,
self.graphics_provider.player_mini_img)
# *after* drawing everything, flip the display
pygame.display.flip()
def change_owner(self, owner):
self.owner = owner
self.color = owner.inverted_color
if random.random() < globals.pw_chance:
globals.powerups.append(Powerup(self.i, self.j))
def generatePowerup(self, pos, vel):
if self.level < 3:
self.powerups.append(
Powerup(pos, conf.POWERUP_LIST[random.randrange(0, 8)], vel))
running = False
# Updated
all_sprites.update()
# mobs and bullets collision.
hits = pygame.sprite.groupcollide(mobs, bullets, True, True)
for hit in hits:
stats.score += 50 - hit.radius
score_board.prep_score()
explode = Explosion(ui_settings, mob_explose_sheet, 64, 64,
hit.rect.center)
explode.effects.play()
all_sprites.add(explode)
# Randomize the chances of getting a powerupsself.
if random.random() > 0.9:
power = Powerup(ui_settings, hit.rect.center)
all_sprites.add(power)
powers.add(power)
m = Mob(ui_settings)
all_sprites.add(m)
mobs.add(m)
# Check if the ship hit the powersself.
powerhits = pygame.sprite.spritecollide(player, powers, True)
if powerhits:
for hit in powerhits:
hit.effects.play()
if hit.power_type == 'shield':
player.shield += random.randrange(10, 20)
if player.shield >= 100:
player.shield = 100
def game(game):
pygame.init()
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
one = pygame.image.load("one.jpg").convert_alpha()
two = pygame.image.load("two.jpg").convert_alpha()
three = pygame.image.load("three.png").convert_alpha()
one = pygame.transform.scale(one, (30, 60))
two = pygame.transform.scale(two, (45, 60))
three = pygame.transform.scale(three, (40, 60))
walls = pygame.sprite.Group()
walls.add(Wall(0, 0, 5, 600))
walls.add(Wall(0, 0, 1000, 5))
walls.add(Wall(1000, 0, 5, 600))
walls.add(Wall(0, 600, 1000, 5))
walls.add(Wall(100, 100, 400, 5))
walls.add(Wall(100, 200, 5, 300))
walls.add(Wall(200, 100, 5, 200))
walls.add(Wall(200, 400, 5, 100))
walls.add(Wall(300, 200, 100, 5))
walls.add(Wall(200, 400, 400, 5))
walls.add(Wall(600, 200, 5, 200))
walls.add(Wall(300, 500, 400, 5))
walls.add(Wall(600, 0, 5, 100))
walls.add(Wall(500, 200, 5, 100))
walls.add(Wall(300, 300, 200, 5))
walls.add(Wall(800, 200, 5, 300))
walls.add(Wall(700, 100, 5, 100))
walls.add(Wall(700, 300, 5, 100))
walls.add(Wall(700, 100, 200, 5))
walls.add(Wall(800, 500, 100, 5))
walls.add(Wall(900, 200, 5, 200))
wlist = walls.sprites()
grid = []
for i in range(13):
curli = []
if i % 2 == 0:
for j in range(10):
curli.append(0)
for item in wlist:
if item.contains(j * 100 + 30, i / 2 * 100):
curli[j] = 1
else:
for j in range(11):
curli.append(0)
for item in wlist:
if item.contains(j * 100, (i - 1) * 50 + 30):
curli[j] = 1
grid.append(curli)
print(grid)
SCREENWIDTH = 1005
SCREENHEIGHT = 605
size = (SCREENWIDTH, SCREENHEIGHT)
screen = pygame.display.set_mode(size)
cd = 0
tic = 0
s1 = 0
s2 = 0
pygame.display.set_caption("Player 1 - " + str(s1) + " Player 2 - " + str(s2))
d = random.randint(0,3)
d2 = random.randint(0,3)
xpos1 = 100*random.randint(0, 9) + 20
ypos1 = 100*random.randint(0, 5) + 35
var = True
while var:
xpos2 = 100 * random.randint(0, 9) + 20
ypos2 = 100 * random.randint(0, 5) + 35
xn = xpos2 // 100
yn = ypos2 // 100
count = 0
if grid[yn * 2][xn] == 1:
count += 1
if grid[yn * 2 + 2][xn] == 1:
count += 1
if grid[yn * 2 + 1][xn] == 1:
count += 1
if grid[yn * 2+1][xn + 1] == 1:
count += 1
if count < 2:
var = False
if game == 2:
player = Tank(xpos1, ypos1, "1", 0)
player2 = Tank(xpos2, ypos2, "2", 0)
if game == 1:
player = Tank(xpos1, ypos1, "1", 1)
player2 = Tank(xpos2, ypos2, "2", 1)
player.setangle(d*30)
player.setangle(0)
player2.setangle(d2*30)
player2.setangle(0)
all_sprites_list = pygame.sprite.Group()
players = pygame.sprite.Group()
p1 = pygame.sprite.Group()
p1.add(player)
p2 = pygame.sprite.Group()
p2.add(player2)
all_sprites_list.add(player)
all_sprites_list.add(player2)
players.add(player)
players.add(player2)
shrinkTime = random.randint(0,1000)
wallbreakTime = random.randint(0,1000)
all_sprites_list.add(walls)
player.walls = walls
player2.walls = walls
carryOn = True
MOVE_RIGHT = 1
MOVE_LEFT = -1
direction = 0
direction2 = 0
SPIN_UP = 1
SPIN_DOWN = -1
angle = 0
angle2 = 0
score= 0
ais = True
p2angle = 0
AIdir = -1
m = 0
last = 0
resetAngle = False
CLOCK = 0
p1shots = 0
p2shots = 0
while carryOn:
CLOCK+=1
screen.fill(WHITE)
for event in pygame.event.get():
if event.type == pygame.QUIT:
carryOn = False
if event.type == KEYDOWN:
if event.key == K_DOWN:
direction = MOVE_LEFT
elif event.key == K_UP:
direction = MOVE_RIGHT
elif event.key == K_LEFT:
angle = SPIN_UP
elif event.key == K_RIGHT:
angle = SPIN_DOWN
elif event.key == K_SPACE:
if player.alive() and p1shots <=5:
bullet = player.shoot()
all_sprites_list.add(bullet)
elif event.key == K_s:
direction2 = MOVE_LEFT
elif event.key == K_w:
direction2 = MOVE_RIGHT
elif event.key == K_a:
angle2 = SPIN_UP
elif event.key == K_d:
angle2 = SPIN_DOWN
elif event.key == K_q:
if player2.alive() and p2shots <= 5:
bullet = player2.shoot()
all_sprites_list.add(bullet)
elif event.type == KEYUP:
if event.key == K_UP:
direction = 0
elif event.key == K_DOWN:
direction = 0
elif event.key == K_RIGHT:
angle = 0
elif event.key == K_LEFT:
angle = 0
elif event.key == K_w:
direction2 = 0
elif event.key == K_s:
direction2 = 0
elif event.key == K_d:
angle2 = 0
elif event.key == K_a:
angle2 = 0
player.setangle(angle)
player.move(direction)
p1shots = 0
p2shots = 0
for item in all_sprites_list.sprites():
if item.getType() == "bullet":
if item.tank == "2":
p2shots += 1
if item.tank == "1":
p1shots += 1
if game == 1:
if ais:
olda = p2angle
p2angle = player2.RAIdir(grid,player)
if olda != p2angle:
tic = 0
if p2angle != -1:
if (p2angle - player2.dir) % 360 < 2 or (player2.dir - p2angle) % 360 < 2:
if tic % 50 == 15 and p2shots <= 5:
if player2.alive():
bullet = player2.shoot()
all_sprites_list.add(bullet)
elif (p2angle - player2.dir) % 360 < 180:
player2.setangle(1)
else:
player2.setangle(-1)
else:
ais = False
else:
if AIdir == -1:
AIdir = player2.AIMove(grid, player, last)
if (AIdir - player2.dir) % 360 < 2 or (player2.dir - AIdir) % 360 < 2:
if m < 20:
player2.move(1)
m += 1
else:
player2.move(0)
last = AIdir
AIdir = -1
m = 0
ais = True
elif (AIdir - player2.dir) % 360 < 180:
player2.setangle(1)
else:
player2.setangle(-1)
tic += 1
if game == 2:
if CLOCK%1000 == shrinkTime:
all_sprites_list.add(Powerup("shrink", 100 * random.randint(0, 9) + 20, 100 * random.randint(0, 5) + 35))
if CLOCK%1000 == wallbreakTime:
all_sprites_list.add(Powerup("wallbreak", 100 * random.randint(0, 9) + 20, 100 * random.randint(0, 5) + 35))
if game == 2:
player2.setangle(angle2)
player2.move(direction2)
num = 0
for item in all_sprites_list:
if item.getType() == "bullet":
num = item.hit(players, p1, p2)
elif item.getType() == "powerup":
num = item.hit(player, player2)
if num == "1":
all_sprites_list.remove(item)
player.setPowerup(item)
elif num == "2":
all_sprites_list.remove(item)
player2.setPowerup(item)
if not(player in all_sprites_list.sprites()):
if not score == 1:
score = -1
elif not(player2 in all_sprites_list.sprites()):
if not score == -1:
score = 1
else:
score = 0
all_sprites_list.update()
if (not player2.alive()) or (not player.alive()):
cd += 1
if cd < 25:
screen.blit(three, (930, 20))
elif 75 > cd > 50:
screen.blit(two, (930, 20))
elif 100 < cd < 125:
screen.blit(one, (930, 20))
if cd == 150:
cd = 0
if not player.alive() and not player2.alive():
s1 += 1
s2 += 1
elif not player.alive():
s2 += 1
elif not player2.alive():
s1 += 1
d = random.randint(0, 3)
d2 = random.randint(0, 3)
xpos1 = 100 * random.randint(0, 9) + 20
ypos1 = 100 * random.randint(0, 5) + 35
var = True
while var:
xpos2 = 100 * random.randint(0, 9) + 20
ypos2 = 100 * random.randint(0, 5) + 35
xn = xpos2 // 100
yn = ypos2 // 100
count = 0
if grid[yn * 2][xn] == 1:
count += 1
if grid[yn * 2 + 2][xn] == 1:
count += 1
if grid[yn * 2 + 1][xn] == 1:
count += 1
if grid[yn * 2 + 1][xn + 1] == 1:
count += 1
if count < 2:
var = False
if game == 2:
player = Tank(xpos1, ypos1, "1", 0)
player2 = Tank(xpos2, ypos2, "2", 0)
if game == 1:
player = Tank(xpos1, ypos1, "1", 1)
player2 = Tank(xpos2, ypos2, "2", 1)
player.setangle(d * 30)
player.setangle(0)
player2.setangle(d2 * 30)
player2.setangle(0)
all_sprites_list = pygame.sprite.Group()
players = pygame.sprite.Group()
p1 = pygame.sprite.Group()
p1.add(player)
p2 = pygame.sprite.Group()
p2.add(player2)
all_sprites_list.add(player)
all_sprites_list.add(player2)
players.add(player)
players.add(player2)
all_sprites_list.add(walls)
player.walls = walls
player2.walls = walls
CLOCK = 0
shrinkTime = random.randint(0, 1000)
wallbreakTime = random.randint(0, 1000)
pygame.display.set_caption("Player 1 - " + str(s1) + " Player 2 - " + str(s2))
all_sprites_list.draw(screen)
pygame.display.flip()
pygame.quit()
def run_game():
pygame.init()
game_settings = Settings()
restored_settings = Settings()
screen = pygame.display.set_mode(
(game_settings.screen_length, game_settings.screen_height))
pygame.display.set_caption("Catch It!")
screen.fill((0, 160, 220))
# Create basket object
basket = Basket(screen, game_settings)
# Create ball object, generate position, draw starting position
ball = Ball(game_settings, screen, basket)
ball.generate_random_pos()
ball.draw_ball()
bullets = Group()
# Create spoiled fruit object, generate position, draw starting position
spoiled_fruits = Group()
spoiled_fruit = SpoiledFruit(game_settings, screen, basket)
spoiled_fruits.add(spoiled_fruit)
spoiled_fruit.generate_random_pos()
spoiled_fruit.draw_ball()
powerup = Powerup(game_settings, screen)
# Create clock object to measure fps
clock = pygame.time.Clock(
) # This creates a Clock object that is used to track time, with the other methods that come along with it.
pygame.font.init() # Initializes font module
fps_font = pygame.font.Font(
None, 30
) # This creates a new font object that we will use to display the fps. 'None' just tells it to use the default pygame font, 30 is font size.
fps_constant = 150
lives_font = pygame.font.Font(None, 30)
play_button = PlayButton(screen, game_settings, 'Play!', 50,
game_settings.screen_height / 2)
play_again_button = PlayButton(screen, game_settings, 'Play Again', 50,
game_settings.screen_height - 200)
play_button.draw_button()
pygame.display.flip()
# Score for how many good fruits are caught.
score = pygame.font.Font(None, 50)
# Pause text when game is paused
pause = pygame.font.Font(None, 100)
while True:
gf.check_events(basket, bullets, screen, game_settings,
restored_settings, play_button, play_again_button,
spoiled_fruits, ball, pause)
if game_settings.game_active == False:
clock.tick()
if game_settings.game_active:
gf.check_spoiledfruit_collisions(ball, basket, game_settings,
screen, spoiled_fruit, bullets,
spoiled_fruits)
gf.check_other_collisions(game_settings, screen, basket, ball,
spoiled_fruits, powerup)
gf.check_powerup_collisions(game_settings, screen, powerup, basket,
bullets)
gf.check_game_assist(game_settings, ball, spoiled_fruits)
gf.update_screen(screen, game_settings, basket, ball, clock,
fps_font, lives_font, bullets, spoiled_fruit,
spoiled_fruits, play_button, play_again_button,
powerup, score, fps_constant)
else:
pygame.display.flip()
args = parser.parse_args()
strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA,
LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
strip.begin()
board = Matrix_board(16, 16)
board.createBoard()
snake = Snake(True, 3, 4, 8, 0)
snake.spawnSnake(strip, Color, board)
apple = Apple()
apple.spawnApple(strip, Color, randint(0, 255))
powerup = Powerup()
print("*** AVAILABLE DEVICES ***")
for device in devices:
print(device)
print("*************************")
print('Press Ctrl-C to quit.')
if not args.clear:
print('Use "-c" argument to clear LEDs on exit')
try:
t1 = threading.Thread(target=gamepadEventListener)
t1.daemon = True
t1.start()