def main():
global dx, dy
g2d.init_canvas((ARENA_W, ARENA_H))
dx = int(g2d.prompt("dx?"))
dy = int(g2d.prompt("dy?"))
g2d.handle_events(update, keydn, None)
g2d.main_loop(5) # Call update 5 times/second
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 main():
global b1, b2
b1 = Ball(40, 80)
b2 = Ball(80, 40)
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.handle_events(update)
g2d.main_loop()
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 main():
g2d.init_canvas((A, B))
global players, rover2
players = g2d.confirm("2 Giocatori?")
print(players)
if players:
rover2 = Rover(arena, 200, B - 100)
g2d.main_loop(update)
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():
global b1, b2, img
b1 = FrogBall(40, 80)
b2 = FrogBall(80, 40)
g2d.init_canvas((ARENA_W, ARENA_H))
img = g2d.load_image("ball.png")
g2d.handle_events(update, keydn, None)
g2d.main_loop(5)
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.main_loop(tick)
def main():
global planets, canvas_w, canvas_h
planets = [] # ex.: try to use a list comprehension
for i in range(5):
p = Planet(100 + i * 40)
planets.append(p)
canvas_w, canvas_h = 600, 600
g2d.init_canvas((canvas_w, canvas_h))
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 planets, canvas_w, canvas_h
planets = [] # ex.: try to use a list comprehension
for i in range(5):
p = Planet(100 + i * 40)
planets.append(p)
canvas_w, canvas_h = 600, 600
g2d.init_canvas((canvas_w, canvas_h))
g2d.handle_events(draw_frame)
g2d.main_loop()
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 reset(self):
self.sprites = g2d.load_image(
"https://tomamic.github.io/images/sprites/moon-patrol.png")
self.background = g2d.load_image(
"https://tomamic.github.io/images/sprites/moon-patrol-bg.png")
#self.game_over = g2d.load_image("moon-patrol-game-over.png") Not Working
self._arena = self._game.arena()
self._hero = self._game.hero()
self._is_game_starting = True
g2d.init_canvas(self._arena.size())
if self._settings['level'] == 'level_1':
g2d.main_loop(self.level_1_tick)
else:
g2d.main_loop(self.level_2_tick)
def __init__(self):
self._game = BubbleBobbleGame()
self._total_levels = self._game.total_levels()
self._sprites = g2d.load_image("bubble-bobble.png")
self._background = g2d.load_image("bubble-bobble-maps.png")
self._menu = g2d.load_image("BB_main_menu.png")
self._end = g2d.load_image("BB_end.png")
self._ready = g2d.load_image("BB_ready_not-ready.png")
self._x_y_background = [(0, 0), (0, 0), (512, 0), (0, 0), (0, 0)]
self._player1_ready, self._player2_ready = False, False
self._time_of_win, self._time_of_lost = 0, 0
self._current_level = 0
self._numbers_scores1 = []
self._numbers_scores2 = []
self._x1, self._x2 = 2, 450
self._win, self._lost = True, True
g2d.init_canvas(self._game.arena().size())
g2d.main_loop(self.tick)
def main():
W, H = 600, 400
g2d.init_canvas((W, H))
values = []
max_val = 0
val = float(g2d.prompt("Val? "))
while val > 0:
values.append(val)
if val > max_val:
max_val = val
val = float(g2d.prompt("Val? "))
if len(values) > 0:
for i, v in enumerate(values):
rect = (0, i * H / len(values), v * W / max_val,
(H / len(values)) - 1)
g2d.fill_rect(rect)
g2d.main_loop()
def main():
g2d.init_canvas((263, 263))
g2d.set_color((127, 0, 0))
sierpinski((10, 10, 243, 243))
g2d.main_loop()
def main():
size = arena.size()
g2d.init_canvas((size.x, size.y))
g2d.main_loop(tick)
def main():
g2d.init_canvas((320, 240))
g2d.main_loop(tick)
def main():
global a
a = Spiral()
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.main_loop(tick)
if self._y < 0 + distance:
self._dy = -self._dy
def val(self):
return self._x, self._y
def color(self):
return self._r, self._green, self._b
def update():
global balls
g2d.clear_canvas() # Clear background
for b in balls:
g2d.set_color((b.color()))
g2d.fill_circle((b.val()), 20) # Draw foreground
b.move()
A = 500
B = 500
g2d.init_canvas((A, B))
b = FallingBall(
20, 20,
A) # l'esercizio sta tutto qui, nel creare due oggetti invece che uno
b1 = FallingBall(300, 300, A)
balls = [b, b1]
g2d.main_loop(update, 30)
def main():
global b1, b2
b1 = Ball((40, 80))
b2 = Ball((80, 40))
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.main_loop(tick)
def gui_play(game: BoardGame):
g2d.init_canvas((game.cols() * W, game.rows() * H))
ui = BoardGameGui(game)
g2d.handle_events(None, ui.mousedown, ui.mouseup)
g2d.main_loop()
def main():
g2d.init_canvas((263, 263))
g2d.set_color((127, 0, 0))
sierpinski((10, 10, 243, 243))
g2d.main_loop()
def main_loop(self):
g2d.main_loop()
#!/usr/bin/env python3
'''
@author Michele Tomaiuolo - http://www.ce.unipr.it/people/tomamic
@license This software is free - http://www.gnu.org/licenses/gpl.html
'''
import g2d
from math import pi, sin, cos
R = 200
g2d.init_canvas((2*R, 2*R))
g2d.set_color((0, 0, 0))
i, angle, r = 0, 0.0, R - 20
while i < 12:
angle = i * 2 * pi / 12
pt1 = R + int(r*cos(angle)), R + int(r*sin(angle))
pt2 = R + int(R*cos(angle)), R + int(R*sin(angle))
g2d.draw_line(pt1, pt2)
i += 1
i, angle, r = 0, 0.0, R - 5
while i < 60:
angle = i * 2 * pi / 60
pt1 = R + int(r*cos(angle)), R + int(r*sin(angle))
pt2 = R + int(R*cos(angle)), R + int(R*sin(angle))
g2d.draw_line(pt1, pt2)
i += 1
g2d.main_loop()
#!/usr/bin/env python3
'''
@author Michele Tomaiuolo - http://www.ce.unipr.it/people/tomamic
@license This software is free - http://www.gnu.org/licenses/gpl.html
'''
import g2d
from random import randrange
def tick():
if g2d.key_pressed("LeftButton"):
x, y = g2d.mouse_position()
g2d.set_color((randrange(256), randrange(256), randrange(256)))
if x <= 25 and y <= 25 and g2d.confirm("Exit?"):
g2d.close_canvas()
else:
g2d.fill_circle((x, y), 25)
g2d.init_canvas((480, 360))
g2d.main_loop(tick)
def main(): g2d.init_canvas((ARENA_W, ARENA_H)) g2d.set_color((0, 0, 255)) g2d.main_loop(update)
def main():
g2d.init_canvas(arena.size())
g2d.handle_keyboard(keydown, keyup)
g2d.main_loop(update, 1000 // 30)
def main():
g2d.init_canvas((320, 240)) # inizializzazione (320x200)
image = g2d.load_image("ball.png") # caricamento immagine
g2d.main_loop(update, 1000 // 30) # richiama funzione 30 volte al secondo
def main():
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.handle_events(update) # Set update to be called...
g2d.main_loop() # ... at 30 fps
def main():
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.main_loop(tick) # call tick 30 times/second
def main():
global a
a = Spiral()
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.handle_events(update)
g2d.main_loop()
def main():
global b
b = Ball(40, 40)
g2d.init_canvas((W, H))
g2d.handle_events(update)
g2d.main_loop()
#!/usr/bin/env python3
'''
@author Michele Tomaiuolo - http://www.ce.unipr.it/people/tomamic
@license This software is free - http://www.gnu.org/licenses/gpl.html
'''
import g2d
g2d.init_canvas((600, 400)) # width, height
g2d.set_color((255, 255, 0)) # red + green = yellow
g2d.fill_rect((150, 100, 250, 200)) # left, top, width, height
g2d.set_color((0, 255, 0))
g2d.draw_line((150, 100), (400, 300)) # point1, point2
g2d.set_color((0, 0, 255))
g2d.fill_circle((400, 300), 20) # center, radius
g2d.set_color((255, 0, 0))
g2d.draw_text("Hello", (150, 100), 40) # text, left-top, font-size
g2d.main_loop() # manage the window/canvas
def main():
global balls
balls = [Ball((40, 80)), Ball((80, 40)), Ball((120, 120))]
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.main_loop(tick)
def main():
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.main_loop(update, 1000 // 30) # Millis
def main():
global sprites
g2d.init_canvas(arena.size())
sprites = g2d.load_image("sprites.png")
g2d.handle_events(update, keydown, keyup)
g2d.main_loop()
def main():
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.main_loop(tick, 5)
def main():
global balls
balls = [Ball(40, 80), Ball(80, 40), Ball(120, 120)]
g2d.init_canvas((ARENA_W, ARENA_H))
g2d.handle_events(update)
g2d.main_loop()
def main():
g2d.init_canvas((600, 600))
g2d.handle_events(update)
g2d.main_loop()
def main():
global a
a = Alien((40, 40))
g2d.init_canvas((480, 360))
g2d.main_loop(tick, 10)
def main():
global b
b = Vehicle((40, 40), 5)
g2d.init_canvas((W, H))
g2d.main_loop(tick)
def main():
g2d.init_canvas(arena.size())
g2d.main_loop(tick)
def main():
g2d.init_canvas(vals(arena.size()))
g2d.handle_events(update, keydown, keyup)
g2d.main_loop()
def gui_play(game: BoardGame):
g2d.init_canvas((game.cols() * W, game.rows() * H))
ui = BoardGameGui(game)
g2d.main_loop(ui.tick)
return x + w / 2, y + h / 2
def htree(rect: (int, int, int, int), level: int):
x, y, w, h = rect
if level == 0 or w < 3 or h < 3: #terminazione
return
if level % 2 == 0: #livello pari dimezzo larghezza
rect1 = x, y, w / 2, h #primo rettangolo sn
rect2 = x + w / 2, y, w / 2, h #secondo rettangolo ds
#print(level,'sn',rect1,'ds',rect2) #debug
else: #livello dispari dimezzo altezza
rect1 = x, y, w, h / 2 #alto
rect2 = x, y + h / 2, w, h / 2 #basso
#print(level,'up',rect1,'down',rect2) #debug
g2d.draw_line(center(rect1), center(rect2))
htree(rect1, level - 1)
htree(rect2, level - 1)
if __name__ == '__main__':
level = int(input('level? ')) ## -1 = infinite
side = 600
g2d.init_canvas((side, side))
g2d.set_color((0, 0, 0))
htree((0, 0, side, side), level)
g2d.main_loop()
def main():
g2d.init_canvas((320, 240))
g2d.handle_events(update)
g2d.main_loop()
