def main():
global arena
arena = Arena((480, 360))
Vehicle(arena, (40, 40), 5)
Vehicle(arena, (80, 80), -5)
g2d.init_canvas(arena.size())
g2d.main_loop(tick)
def reset(self, lives: int, settings: dict, score: int):
self._settings = settings
self._arena = Arena((ARENA_W, ARENA_H))
self._arena.add_to_score(score)
Mountain(self._arena, (MOUNTAIN_X, MOUNTAIN_Y))
Hill(self._arena, (HILL_X, HILL_Y), self._settings['level'])
self._ground = Ground(self._arena, (GROUND_X, GROUND_Y), self._settings['difficulty'])
self._start_time = time()
self.bg_list = [Mountain, Hill, Ground]
self._time_to_generate_alien = time()
self._hero = []
self._hero.append(Rover(self._arena, (ROVER_X, ROVER_Y), 1))
if self._settings['mode'] == 'co-op':
self._hero.append(Rover(self._arena, (ROVER_2_X, ROVER_2_Y), 2))
self._start = time()
self._playtime = 80
self.hero_lives = lives
self._aliens = []
self._obstacles = []
self._type_obstacles = [Rock, Hole]
self._rand_x_bomb = 0
self._time_to_generate_bomber = time()
self._bomb_ready = False
self._second = time()
if self._settings['difficulty'] == 'Easy':
self.OBS_RANGE = 400
elif self._settings['difficulty'] == 'Normal':
self.OBS_RANGE = 300
else:
self.OBS_RANGE = 200
def main():
global arena
arena = Arena((320, 240))
Alien(arena, (40, 40))
Alien(arena, (80, 80))
g2d.init_canvas(arena.size())
g2d.main_loop(tick)
def __init__(self, arena: Arena, x: int, y: int):
self._x = x
self._y = y
self._dx = 5
self._dy = 0
self._g = 0.3
self._arena = arena
arena.add(self)
def __init__(self, arena: Arena, x: int, y: int):
self._x = x
self._y = y
self._dx = 5
self._dy = 0
self._g = 0.3
self._arena = arena
arena.add(self)
def main():
global arena
arena = Arena(320, 240)
Alien(arena, 40, 40)
Alien(arena, 80, 80)
g2d.init_canvas(arena.size())
g2d.handle_events(update)
g2d.main_loop()
def main():
arena = Arena((480, 360))
Ball(arena, (40, 80))
Ball(arena, (80, 40))
Ghost(arena, (120, 80))
for i in range(25):
print_arena(arena)
arena.move_all()
def main():
arena = Arena(320, 240)
Ball(arena, 40, 80)
Ball(arena, 80, 40)
Ghost(arena, 120, 80)
for i in range(25):
print_arena(arena)
arena.move_all()
def main():
global arena, turtle, sprites
arena = Arena(320, 240)
for i in range(5):
Ball(arena)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.main_loop(update, 1000 // 30) # millis
def main():
global arena, turtle, sprites
arena = Arena(320, 240)
turtle = Turtle(arena, 80, 80)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.main_loop(tick)
def main():
global arena, sprites
arena = Arena(320, 240)
Ball(arena, 40, 80)
Ball(arena, 85, 40)
Wall(arena, 115, 80, 100, 20)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.main_loop(tick)
def main():
global arena, turtle, sprites
arena = Arena(320, 240)
turtle = Turtle(arena, 80, 80)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.handle_events(update, keydown, keyup)
g2d.main_loop()
def main():
global arena, sprites
arena = Arena(320, 240)
Ball(arena, 40, 80)
Ball(arena, 85, 40)
Wall(arena, 115, 80, 100, 20)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.handle_events(update)
g2d.main_loop()
def main():
global arena, mario, sprites, background
arena = Arena(224, 256)
mario = Mario(arena, 50, 230)
Barrel(arena, 180, 70)
Barrel(arena, 150, 70)
for t, x, y, w, h in map_elements:
if t == "Platform":
Platform(arena, int(x), int(y))
elif t == "Ladder":
Ladder(arena, int(x), int(y), int(h))
game2d.canvas_init(arena.size())
sprites = game2d.image_load("dk_sprites.png")
background = game2d.image_load("dk_background.png")
game2d.handle_keyboard(keydown, keyup)
game2d.set_interval(update, 1000 // 30) # millis
def main():
global arena, view_x, view_y, view_w, view_h, background
arena = Arena(500, 250)
FallingBall(arena, 40, 80)
FallingBall(arena, 80, 40)
Plane(arena, 60, 60)
view_x, view_y, view_w, view_h = 0, 0, 300, 200
g2d.init_canvas((view_w, view_h))
background = g2d.load_image("https://raw.githubusercontent.com/tomamic/fondinfo/gh-pages/images/oop/viewport.png")
g2d.main_loop(tick)
def __init__(self):
self._arena = Arena((512, 456))
self._scores = Score()
self._levels = ["BB_main_menu.csv", "BB_level_1.csv", "BB_level_2.csv", "BB_end.csv"]
self._config_Enemy, self._config_Dragon = "BB_config_Enemy_out_of_map.csv", "BB_config_Dragon_out_of_map.csv"
self._game_length = (len(self._levels) - 1)
self._cont_enemy, self._cont_killed = 0, 0
self._points1, self._points2 = 0, 0
self._coordinates1 = []
self._coordinates2 = []
self._enemies = []
self._walls = []
self._player = []
self._win = False
self._player1_ready, self._player2_ready = False, False
self.levels(0, True, True)
class MoonPatrolGame:
def __init__(self, settings):
self.reset(3, settings, 0)
def arena(self) -> Arena:
return self._arena
def reset(self, lives: int, settings: dict, score: int):
self._settings = settings
self._arena = Arena((ARENA_W, ARENA_H))
self._arena.add_to_score(score)
Mountain(self._arena, (MOUNTAIN_X, MOUNTAIN_Y))
Hill(self._arena, (HILL_X, HILL_Y), self._settings['level'])
self._ground = Ground(self._arena, (GROUND_X, GROUND_Y), self._settings['difficulty'])
self._start_time = time()
self.bg_list = [Mountain, Hill, Ground]
self._time_to_generate_alien = time()
self._hero = []
self._hero.append(Rover(self._arena, (ROVER_X, ROVER_Y), 1))
if self._settings['mode'] == 'co-op':
self._hero.append(Rover(self._arena, (ROVER_2_X, ROVER_2_Y), 2))
self._start = time()
self._playtime = 80
self.hero_lives = lives
self._aliens = []
self._obstacles = []
self._type_obstacles = [Rock, Hole]
self._rand_x_bomb = 0
self._time_to_generate_bomber = time()
self._bomb_ready = False
self._second = time()
if self._settings['difficulty'] == 'Easy':
self.OBS_RANGE = 400
elif self._settings['difficulty'] == 'Normal':
self.OBS_RANGE = 300
else:
self.OBS_RANGE = 200
def hero(self) -> Rover:
return self._hero
def hero_shoot_straight(self, i: int):
Bullet(self._arena, (self._hero[i].get_x() + 50, 580), 'straight', 'normal', self._settings['difficulty'])
def hero_shoot_up(self, i: int):
Bullet(self._arena, (self._hero[i].get_x() + 8, 540), 'up', 'normal', self._settings['difficulty'])
def game_over(self) -> bool:
if self.hero_lives == 0:
return True
else:
return False
def in_game(self) -> bool:
if any(isinstance(a, Rover) for a in self._arena.actors()):
return True
else:
return False
def game_won(self) -> bool:
return time() - self._start > self._playtime
def remaining_time(self) -> int:
return int(self._start + self._playtime - time())
def generate_random_obstacles(self):
obstacleInRange = True
rand_obs = randint(0, ARENA_W * 2)
rand_dim_o = randint(1, 2)
for o in self._obstacles:
if o.get_x() == rand_obs:
obstacleInRange = False
if obstacleInRange:
if self._ground.is_not_in_canvas(rand_obs) == True:
for obs in self._obstacles:
if not(rand_obs <= obs.get_x() - self.OBS_RANGE or rand_obs >= obs.get_x() + self.OBS_RANGE):
obstacleInRange = False
if obstacleInRange:
obstacle = choice(self._type_obstacles)
self._obstacles.append(obstacle(self._arena, (rand_obs, OBS_Y), rand_dim_o, self._settings['difficulty']))
def generate_alien(self):
self._aliens.clear()
actors = self._arena.actors()
for a in actors:
if type(a) is Alien:
self._aliens.append(a)
if len(self._aliens) < 2 and time() - self._time_to_generate_alien > 20:
rand_x_alien = randint(100, 740)
rand_y_alien = randint(150, 250)
self._aliens.append(Alien(self._arena, (rand_x_alien, rand_y_alien), self._settings['level']))
self._time_to_generate_alien = time()
def generate_random_bullet_from_aliens(self):
if time() - self._start_time > 8:
for alien in self._aliens:
Bullet(self._arena, (alien.get_x() + 5, alien.get_y() + 10), 'down', 'normal', self._settings['difficulty'])
self._start_time = time()
def generate_cannon(self):
if self._ground.get_x() < ARENA_W:
actors = self._arena.actors()
cannon_available = True
rand_cannon_x = randint(ARENA_W, ARENA_W*2)
for a in self._obstacles:
if isinstance(a, Cannon) or rand_cannon_x == a.get_x():
cannon_available = False
if cannon_available:
self._obstacles.append(Cannon(self._arena, (rand_cannon_x, 570)))
def cannon_shoot(self):
for o in self._obstacles:
if isinstance(o, Cannon):
if not(self._ground.is_not_in_canvas(o.get_x())):
if time() - o.get_start_time() > 3:
Bullet(self._arena, (o.get_x() - 10, 580), 'backward', 'cannon', self._settings['difficulty'])
o.set_start_time(time())
def update_obstacles(self):
self._obstacles.clear()
for a in self._arena.actors():
if isinstance(a, Rock) or isinstance(a, Hole) or isinstance(a, Cannon):
self._obstacles.append(a)
def ground_boost(self):
for o in self._obstacles:
o.boost()
def ground_release_boost(self):
for o in self._obstacles:
o.release_boost()
def generate_bomber(self):
if time() - self._time_to_generate_bomber > 8:
Bomber(self._arena, (0, 80))
self._rand_x_bomb = randint(0, ARENA_W)
self._bomb_ready = True
self._time_to_generate_bomber = time()
def bomber_shoot(self):
for a in self._arena.actors():
if isinstance(a, Bomber):
if a.get_x() >= self._rand_x_bomb and self._bomb_ready:
self._bomb_ready = False
Bullet(self._arena, (a.get_x(), 88), 'down', 'bomb', self._settings['difficulty'])
def add_second_to_score(self):
if time() - self._second > 1:
if self._settings['difficulty'] == 'Hard':
self._arena.add_to_score(3)
elif self._settings['difficulty'] == 'Normal':
self._arena.add_to_score(2)
else:
self._arena.add_to_score(1)
self._second = time()
larger image, containing more sprites
Returns:
(int, int) -- the position of current sprite
'''
return
def update():
canvas_fill(canvas, (0, 0, 0))
arena.move_all()
for a in arena.actors():
x1, y1, aw, ah = a.rect()
draw_rect(canvas, (0, 255, 255), (x1, y1, 50, 50))
arena = Arena(1000, 1000)
f1 = FallingBall(10, 10)
f2 = FallingBall(70, 70)
p1 = Plane(1, 350)
p2 = Plane(1, 250)
p3 = Plane(1, 150)
arena.add(f1)
arena.add(f2)
arena.add(p1)
arena.add(p2)
arena.add(p3)
canvas = canvas_init((1000, 1000))
set_interval(update, 1000 // 30)
from raft import Raft
from fiume import Fiume
from frog import Frog
from vehicle import Vehicle
from turtle import Turtle
from land import Land
from crocodile import Crocodile
import pygame #Gestione audio
veicoli = []
raft = []
frog = []
turtle = []
crocodile = []
land = []
arena = Arena(600, 480)
logo = g2d.load_image("Frogger-logo.png")
background = g2d.load_image("frogger_bg.png")
sprite = g2d.load_image("frogger_sprites.png")
gameover = g2d.load_image("gameover.png")
win = g2d.load_image("win.png")
pygame.mixer.init()
pygame.mixer.music.load("froggeraudio.mp3")
pygame.mixer.music.play()
for i in range(0, 4):
x = randint(100, 200)
raft.append(Raft(arena, x, int((i * 40) + 80), 0))
raft.append(Raft(arena, x + 270, int((i * 40) + 80), 1))
raft.append(Raft(arena, x + 520, int((i * 40) + 80), 2))
for i in range(0, 4):
if (i % 2 == 0):
if g2d.key_pressed("Spacebar"):
mario.jump()
elif g2d.key_pressed("ArrowLeft"):
mario.go_left()
elif g2d.key_pressed("ArrowRight"):
mario.go_right()
elif (g2d.key_released("ArrowLeft") or g2d.key_released("ArrowRight")):
mario.stay()
arena.move_all() # Game logic
g2d.clear_canvas()
for a in arena.actors():
if isinstance(a, Wall):
g2d.fill_rect(a.position())
else:
g2d.draw_image_clip(sprites, a.symbol(), a.position())
arena = Arena(320, 240)
mario = Mario(arena, 80, 80)
CrazyGoomba(arena, 180, 80)
CrazyGoomba(arena, 150, 80)
Wall(arena, 200, 80, 80, 20)
Wall(arena, 120, 160, 80, 20)
Wall(arena, 0, 220, 320, 20)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.main_loop(tick)
pass
def collide(self, other):
if isinstance(other, Ball) and self._count == 0:
self._raft = other
def position(self):
return self._x, self._y, self._w, self._h
def symbol(self):
return 0, 20, self._w, self._h
###
arena = Arena(320, 240)
b1 = Ball(arena, 40, 60, 5)
b2 = Ball(arena, 80, 40, -5)
turtle = Turtle(arena, 80, 80)
def tick():
if g2d.key_pressed("ArrowUp"):
turtle.go_up()
elif g2d.key_pressed("ArrowRight"):
turtle.go_right()
elif g2d.key_pressed("ArrowDown"):
turtle.go_down()
elif g2d.key_pressed("ArrowLeft"):
turtle.go_left()
elif (g2d.key_released("ArrowUp") or
g2d.key_released("ArrowRight") or
if isinstance(a, Wall):
g2d.fill_rect(a.position())
else:
g2d.draw_image_clip(sprites, a.symbol(), a.position())
def keydown(code):
print("#"+code+"#")
if code == "Space":
mario.jump()
elif code == "ArrowLeft":
mario.go_left()
elif code == "ArrowRight":
mario.go_right()
def keyup(code):
if code in ("ArrowLeft", "ArrowRight"):
mario.stay()
arena = Arena(320, 240)
mario = Mario(arena, 80, 80)
CrazyGoomba(arena, 180, 80)
CrazyGoomba(arena, 150, 80)
Wall(arena, 200, 80, 80, 20)
Wall(arena, 120, 160, 80, 20)
Wall(arena, 0, 220, 320, 20)
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.handle_events(update, keydown, keyup)
g2d.main_loop()
def move(self):
self._x -= self._speed
if self._x + self._w < 0:
self._x += self._w
def collide(self, other):
pass
def position(self):
return self._x, self._y, self._w, self._h
def symbol(self):
return 0, self._ys, self._w, self._h
arena = Arena((480, 360))
back = Background(arena, 120, 128, 256, 2)
sprites = g2d.load_image("moon-patrol.png")
bg = g2d.load_image("moon-patrol-bg.png")
def tick():
arena.move_all() # Game logic
g2d.clear_canvas()
for a in arena.actors():
if isinstance(a, Background):
ax, ay, aw, ah = a.position()
g2d.draw_image_clip(bg, a.symbol(), (ax, ay, aw, ah))
g2d.draw_image_clip(bg, a.symbol(), (ax + aw, ay, aw, ah))
elif a.symbol() != (0, 0, 0, 0):
