def create_game(window):
game = Game()
game.window = window
game.close_selected = False
small_radius = 30
small_center = generate_center(game, small_radius)
game.small_dot = create_dot('red', small_radius, small_center, [1, 2])
big_radius = 40
big_center = generate_center(game, big_radius)
game.big_dot = create_dot('blue', 40, big_center, [2, 1])
game.clock = Clock()
game.window.set_font_name('ariel')
game.window.set_font_color('white')
game.window.set_font_size(40)
return game
def run(self):
clock = Clock()
self.set_keyboard_listener()
self.drawer.start()
ser = serial.Serial("COM3", 19200)
print("record mode: " + str(self.record_mode))
while self.isrunning:
clock.tick(120)
msg = cmd_to_packet(self.current2cmd())
# print(msg)
ser.write(f"{msg}\r\n".encode("utf-8"))
self.listener.stop()
self.drawer.isrunning = False
print("pad exit")
def main():
window = create_window()
# create game
clock = Clock()
small_color = "red"
small_center = [50, 100]
small_radius = 30
small_velocity = [1, 2]
small_dot = [small_color, small_center, small_radius, small_velocity]
big_color = "blue"
big_center = [200, 100]
big_radius = 40
big_velocity = [2, 1]
play_game(window, small_dot, big_color, big_center, big_radius, big_velocity, clock)
window.close()
def run_game_real_speed(nn: FastNeuralNetwork):
game = BirdGame()
clock = Clock()
while 1:
if game.is_game_over():
return game.score
if game.score > 4000:
return game.score
output = nn.feedfordward(
np.array([[game.distance_to_wall[0] / 800],
[game.distance_to_wall[1] / 600],
[game.bird_center[1] / 600], [game.bird_speed[1]]]))
game.next_frame(output[0][0] > 0.5)
clock.tick(200)
def __init__(self, x, y, width, height, title=None, coverfilename=None):
"""
Initialise the MPlayer Visualization Goom
"""
logger.debug('%s.__init__(x=%r y=%r width=%r height=%r coverfilename=%r)',
self.__class__, x, y, width, height, coverfilename)
self.mode = MpvMode(config.MPLAYERVIS_MODE)
self.coverfilename = coverfilename
self.showfps = False
if not os.path.exists(MMAP_FILE):
f = open(MMAP_FILE, 'w')
s = str(chr(0)) * 2064
f.write(s)
f.close()
#pygoom.debug(2)
BaseAnimation.__init__(self, (x, y, width, height), fps=100, bg_update=False, bg_redraw=False)
# goom doesn't handle Unicode, so make it a string
self.goom = pygoom.PyGoom(width, height, MMAP_FILE, songtitle=self.to_str(title) or '')
self.infodata = None
self.width = width
self.height = height
self.fade_step = config.MPLAYERVIS_FADE_STEP
self.init_counter = self.fade_step * config.MPLAYERVIS_INIT_COUNTER
self.fade_in_wait_counter = self.fade_step * config.MPLAYERVIS_FADE_IN_WAIT_COUNTER
self.fade_out_wait_counter = self.fade_step * config.MPLAYERVIS_FADE_OUT_WAIT_COUNTER
self.fade_counter = self.fade_step * config.MPLAYERVIS_FADE_COUNTER
self.fade_machine = {
'init': self.init_state,
'fade_out_wait': self.fade_out_wait_state,
'fade_out': self.fade_out_state,
'fade_in_wait': self.fade_in_wait_state,
'fade_in': self.fade_in_state,
}
self.state = self.fade_machine['init']
self.counter = self.init_counter
self.fader = lambda n, m: int(float(n-m)/float(2))
self.alpha = self.set_alpha(self.counter, 0)
self.clock = Clock()
self.running = False
self.timer = Timer(self.goom_surface_update)
self.last_time = 0
self.message_counter = 1 # skip message at start
self.message = ''
def main():
pygame.init()
pygame.display.set_caption("GUI testing")
screen = pygame.display.set_mode((1080, 920))
screen.fill((0, 0, 0))
gui_manager = GUI(screen)
menu_manager = GUI(screen)
menu_manager.set_background_color(Color.black)
def clickered():
print("Clicked!")
text_options = {
"horizontal_align": Text.ALIGN_CENTER,
"vertical_align": Text.ALIGN_CENTER,
}
test_button = Button(text="test",
on_click=clickered,
position=Position(80, 80),
shape=Rect(80, 40),
color=Color.light_grey.lighten(),
text_options=text_options)
gui_manager.add_element(test_button)
cpos = 500
running = True
clock = Clock()
while running:
# DEBUG: Set low framerate for debugging
clock.tick_busy_loop(5)
Input._refresh_keys()
cpos -= 1
if cpos <= 0: cpos = 500
if Input.key_down(pygame.K_ESCAPE):
openMenu()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# gui_manager.update()
screen.fill((30, 103, 203))
pygame.draw.circle(screen, (255, 255, 255), [cpos, 255], 30)
pygame.display.update()
print("Safely quit the progaram")
def __init__(self):
"""Initializes a new InvadersGame, with all parameters properly set"""
super(InvadersGame, self).__init__(width=RESX, height=RESY, fps=120,
collision_events_enabled=False,
window_text="CITIUS-invaders")
self.gensprite = sge.gfx.Sprite(width=RESX, height=RESY, origin_x=0,
origin_y=0)
self.scoresprite = sge.gfx.Sprite(width=320, height=120,
origin_x=100, origin_y=100)
self.hud_font = sge.gfx.Font('minecraftia.ttf', size=20)
self.pairs = None
self.score = 0
self.anim_sleep = None
self.last_gen = 0
self.game_over = False
self.clock = Clock()
def main():
window = create_window()
# create game
clock = Clock()
small_color = 'red'
small_radius = 30
small_center = [50, 75]
small_velocity = [1, 2]
big_color = 'blue'
big_radius = 40
big_center = [200, 100]
big_velocity = [2, 1]
play_game(window, small_color, small_center, small_radius, small_velocity, big_color, big_center, big_radius,
big_velocity, clock)
window.close()
def run(self):
running = True
clock = Clock()
while running:
self.fill_background(color=(0, 0, 0))
for event in self.get_events():
if event.type == pygame.QUIT:
running = False
self.pad.handle(event)
self.all_sprites.update()
self.all_sprites.draw(self.window.screen)
self.render()
clock.tick(FPS)
return 0
def menu_loop(self):
clock = Clock()
while self.__state != QUIT:
self.update()
clock.tick(30)
self.__screen.update()
for event in pg.event.get():
if event.type == pg.QUIT:
self.__config['player_number'] = 0
self.__state = QUIT
self.clear_buttons()
self.__background.destroy()
return self.__config
def __init__(self, ctx): pygame.display.init() pygame.font.init() pygame.display.set_caption(ctx["game_title"]) self._window = pygame.display.set_mode((ctx["game_width"], ctx["game_height"]), 0, 0) self._adjust_window(ctx) self._clock = Clock() self._frame_rate = ctx["game_frame_rate"] self._close_selected = False self._continue_game = True self._score = 0 self._small_dot = Dot(self._window, ctx["small_dot_color"], ctx["small_dot_center"], ctx["small_dot_radius"], ctx["small_dot_velocity"]) self._big_dot = Dot(self._window, ctx["big_dot_color"], ctx["big_dot_center"], ctx["big_dot_radius"], ctx["big_dot_velocity"]) self._small_dot.randomize() self._big_dot.randomize() pygame.display.update()
def start_display_output(self):
""" Start thread for graphical VU meter """
pygame.event.clear()
clock = Clock()
self.meter.start()
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.exit()
elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
keys = pygame.key.get_pressed()
if (keys[pygame.K_LCTRL] or keys[pygame.K_RCTRL]) and event.key == pygame.K_c:
self.exit()
self.refresh()
clock.tick(1)
def __init__(self):
# Pygame launch
pygame.display.set_caption("SANTARENA")
# Screen (camera)
self.camera = Camera()
# Tilemap
self.tilemap = Tilemap(MAP_H, MAP_W)
# Characters
self.character = Character()
self.enemies = []
# Clock
self.clock = Clock()
self.dt = 0
def __init__(self):
self.screen_size = (450, 600)
self.title = "Week 06"
self.clock = Clock()
self.delta = 0
self.time_since_started = 0
pygame.init()
self.time_since_started = pygame.time.get_ticks()
self.screen_surf = pygame.display.set_mode(self.screen_size,
pygame.RESIZABLE)
pygame.display.set_caption(self.title)
self.game_screen = IntroScreen()
self.is_running = True
def __init__(self, name, current_theme, field=None):
"""
Make game window
"""
theme.set_theme_module(current_theme)
if field:
theme.FIELD_WIDTH, theme.FIELD_HEIGHT = field
UserInterface.sprites_all = pygame.sprite.LayeredUpdates()
UserInterface.sprites_by_layer = [
pygame.sprite.LayeredUpdates(layer=i)
for i in range(theme.MAX_LAYERS + 1)
]
pygame.init()
screenrect = Rect((0, 0), (theme.FIELD_WIDTH, theme.FIELD_HEIGHT))
self.screen = set_mode(screenrect.size)
set_caption(name)
self.background = pygame.Surface(self.screen.get_size()) # и ее размер
self.background = self.background.convert()
try:
image = load_image(theme.BACKGROUND_IMAGE, -1)
self.background.blit(image, (0, 0))
except (SystemExit, AttributeError):
self.background.fill(theme.BACKGROUND_COLOR) # заполняем цветом
self.clear_screen()
global clock
clock = Clock()
self.fps_meter = Fps(color=(255, 255, 0))
self.game_over_indicator = GameOver()
self._step = 0
self.debug = False
self.game_objects = {}
self.ui_state = UserInput()
self._debug = False
self.child_conn = None
self._game_over = False
def main():
clock = Clock()
clear_file(log_file_path)
enc = sensors.Encoders()
enc.get_ticks() # clears previous stored values
start = time.time()
while True:
end = time.time()
period = end - start
actual_freq = 1 / period
print("{}Hz".format(actual_freq))
start = end
l, r = enc.get_ticks()
data = [l, r]
log_data(log_file_path, data)
print(data)
clock.tick(freq)
def load_level(self):
self.begin = [0, 0]
self.mobs = Group()
self.sprites = Group()
self.sprites_and_bombs = Group()
self.grass = Group()
self.bonuses = Group()
try:
f = open('Resources\level' + str(self.lvl) + '.txt', 'r')
except:
self.the_end(True)
return
self.screen.blit(load('Resources\images\loading.jpg'), (0, 0))
update()
timer = Clock()
for i in range(25):
timer.tick(60)
self.board = [s[0:(len(s) - 1)] for s in f.readlines()]
n = len(self.board)
m = len(self.board[0])
for i in range(n):
for j in range(m):
(x, y) = j * 40, i * 40 + 50
if self.board[i][j] == '1':
self.sprites.add(
Sprites('Tiles\\1.png', x, y, self.begin, False))
else:
self.grass.add(Sprites('Tiles\\0.png', x, y, self.begin))
if '2' <= self.board[i][j] <= '9':
s = Sprites('Tiles\\2.png', x, y, self.begin)
self.sprites.add(s)
if self.board[i][j] != '2':
self.bonuses.add(
Bonus(x, y, int(self.board[i][j]), self.begin,
s))
elif self.board[i][j] == 'P':
self.start_pos = (x, y)
self.hero = Player(x, y, self.max_bombs, self.strength,
self.begin, m * 40, n * 40)
elif self.board[i][j] != '0':
self.mobs.add(
Mobs(self.board[i][j], x, y, 1.0 + self.lvl * 0.5,
randint(0, 3), self.begin))
f.close()
self.sprites_and_bombs = self.sprites.copy()
self.start = get_ticks()
def main():
global fire_grp, all_sprites
pygame.init()
screen = pygame.display.set_mode([screen_w, screen_h])
all_sprites = pygame.sprite.Group()
asteroids_grp = pygame.sprite.Group()
fire_grp = pygame.sprite.Group()
player_ship = StarShip()
all_sprites.add(player_ship)
all_sprites.add(fire_grp)
all_sprites.add(asteroids_grp)
all_sprites.add(player_ship)
for i in range(5):
ast = Astroid([screen_w, screen_h])
asteroids_grp.add(ast)
all_sprites.add(ast)
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
running = False
if len(asteroids_grp) < 1:
running = False
screen.fill((0, 0, 0))
move(all_sprites)
draw(all_sprites, screen)
if checkCollid(player_ship, asteroids_grp, fire_grp):
running = False
handle_keys(player_ship)
pygame.display.update()
Clock().tick(FPS)
pygame.quit()
def __init__(self, width, height, scale, shared_buffer) -> None:
self.width = width
self.height = height
self.scale = scale
self.buffer = shared_buffer
self.frame = framebuf.FrameBuffer(shared_buffer, width, height,
framebuf.MONO_VLSB)
self.window_size = (width * scale, height * scale)
pyg_display.init()
pyg_display.set_caption("SSD1306_EMU")
self.surface = pyg_display.set_mode(self.window_size,
flags=L.DOUBLEBUF,
vsync=1)
self.clock = Clock()
self.invert = False
self.contrast = 255
self.power = True
def __init__(self, parse, name=""):
init()
display.init()
self.DIMS = (display.Info().current_w, display.Info().current_h)
self.BG = Surface(self.DIMS)
self.SCREEN = display.set_mode(self.DIMS, -2147483648)
self.MANAGER = UIManager(self.DIMS)
set_visible(True)
update()
Exit((0, 0), self.MANAGER)
clear = Clear((0, 30), self.MANAGER)
Spawn((0, 60), self.MANAGER, clear, self.DIMS, parse, name)
Killer((0, 90), self.MANAGER, clear)
Paint((0, 120), self.MANAGER)
self.clock = Clock()
while True:
self.process_events()
def main():
pygame.init()
screen = pygame.display.set_mode(config.DISPLAY)
pygame.display.set_caption(config.TITLE)
pygame.font.init()
myfont = pygame.font.SysFont('Sans', 16)
bg = Background((config.WIN_WIDTH, config.WIN_HEIGHT))
game_map = BgMap(*config.MAP_POS)
hero = Player(*config.PLAYER_POS)
xvel = yvel = 0
show_grid = False
map_grid = MapGrid(game_map.rect.width, game_map.rect.height,
config.GRID_SIZE)
timer = Clock()
while True:
for event in pygame.event.get():
event_exit(event)
xvel, yvel = event_move(event, xvel, yvel)
if event.type == pygame.KEYDOWN and event.key == pygame.K_h:
game_map.x = config.MAP_POS[0]
game_map.y = config.MAP_POS[1]
if event.type == pygame.KEYDOWN and event.key == pygame.K_g:
show_grid = not show_grid
bg.draw(screen)
game_map.update(xvel, yvel)
game_map.draw(screen)
if show_grid:
map_grid.draw(screen)
hero.draw(screen)
coords = "{}, {}".format(game_map.x, game_map.y)
text_surface = myfont.render(coords, False, (0, 0, 0))
screen.blit(text_surface, (0, 0))
pygame.display.update()
timer.tick(24)
def __init__(self, name, shots=[], dir="figs", comic_strip=None):
self.dir = os.path.join(os.getcwd(), dir)
if not os.path.exists(self.dir):
os.makedirs(self.dir)
self.clock = Clock()
self.name = name
try:
self.shots = sorted(shots)
self.remaining_shots = sorted(shots)
except TypeError:
self.shots = shots
self.remaining_shots = shots
self.total_ticks = 0
self.made_comic_strip = False
self.comic_strip = comic_strip
def solve_level(last_level=False):
def loop():
nonlocal orders, order_num
current_orders = vision.get_requests()
for i in range(6):
if orders[i] != current_orders[i]:
if current_orders[i] is not None:
print(f'Customer at seat {i}, order id: {current_orders[i]}_{order_num}')
FoodThread(current_orders[i], name=f'{current_orders[i]}_{order_num}').start()
order_num += 1
else:
timer = threading.Timer(5.1, plate_timer, [i, orders[i]])
timer.setDaemon(True)
timer.start()
orders = current_orders
global stock
order_num = 0
orders = [None] * 6
stock = Stock()
ordering_thread = OrderingThread()
ordering_thread.setDaemon(True)
ordering_thread.start()
last_check = time.time()
while running:
clock = Clock()
loop()
clock.tick(30)
if (time.time() - last_check) > 5:
if gi.vision.level_ended():
ordering_thread.running = False
check_ingredients_event.set()
check_ingredients_event.clear()
ordering_thread.join()
if not last_level:
for button in gi.bl.next_level:
button()
return
last_check = time.time()
def __init__(self):
pygame.init()
self.CLOCK = Clock()
self.ROWS_COLS = 15
self.GRID_SIZE = 50
self.SCREEN_SIZE = self.GRID_SIZE * self.ROWS_COLS
self.DISPLAY = display.set_mode((self.SCREEN_SIZE, self.SCREEN_SIZE))
self.BACKGROUND_COLOR = (0, 0, 0)
self.GRID_COLOR = (100, 100, 100)
self.SNAKE_COLOR = (0, 255, 0)
self.apple_generator = AppleGenerator(self.ROWS_COLS, self.GRID_SIZE)
self.apple = self.apple_generator.generate_apple(self.snake)
mid = (self.ROWS_COLS // 2) * self.GRID_SIZE
self.start_x_y = (mid, mid)
self.snake = Snake(self.start_x_y, self.GRID_SIZE, self.SCREEN_SIZE,
self.SNAKE_COLOR, self.spawn_apple)
self.exit_clicked = None
self.playing = None
def __init__(self):
self.clock: Clock = Clock()
self.context: Context = Context()
self.context.bar_keeper = BarKeeper(8, 4)
bar_room = BarRoom()
bar_room.sprites.append(
self.context.bar_keeper
)
self.context.rooms[Context.BAR_ROOM] = bar_room
store_room = StoreRoom()
store_room.sprites.append(
self.context.bar_keeper
)
self.context.rooms[Context.STORE_ROOM] = store_room
self.context.set_room(Context.BAR_ROOM)
self.context.sidebar = SideBar()
self.render_context = RenderContext((1920, 1080))
self.running = True
def __init__(self, defaults, window_attributes):
random.seed()
Game.__Game.__FPS = defaults["FPS"]
pygame.init()
self.time_since_started = pygame.time.get_ticks()
self.clock = Clock()
self.delta = 0
self.screen = pygame.display.set_mode(window_attributes["size"])
pygame.display.set_caption(window_attributes["caption"])
from src.scene import Scene
self.scene = Scene()
self.is_start = False
self.is_run = False
def main():
run = True
start_node = grid[5][5]
clock = Clock()
while run:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
dfs(grid, start_node)
# start_node.visit()
# start_node.update_neighbours()
# for neighbor in start_node.neighbours:
# if not neighbor.visited:
# start_node = neighbor
pygame.display.flip()
def __init__(self, gui_left_upper, caption="Basic Model", gui_right_upper=None,
patch_size=11, board_rows_cols=(51, 51), clear=None, bounce=None, fps=None):
# Constants for the main loop in start() below.
self.CTRL_D = 'D:68'
self.CTRL_d = 'd:68'
self.ESCAPE = 'Escape:27'
self.NORMAL = 'normal'
self.Q = 'Q'
self.q = 'q'
self.clock = Clock()
SimEngine.fps = fps if fps else 60
self.idle_fps = 10
SimEngine.simple_gui = SimpleGUI(gui_left_upper, caption=caption, gui_right_upper=gui_right_upper,
patch_size=patch_size, board_rows_cols=board_rows_cols,
clear=clear, bounce=bounce, fps=fps)
self.graph_point = None
def main():
# Create game
window = create_window()
clock = Clock()
# - Create small dot
small_color = 'red'
small_radius = 20
small_center = [200,100]
small_velocity = [1, 2]
# - Create big dot
big_color = 'blue'
big_radius = 40
big_center = [200,100]
big_velocity = [2, 1]
play_game(window, big_color, big_center, big_radius, big_velocity,
small_color, small_center, small_radius, small_velocity, clock)
window.close()
def on_bootstrap(
self,
window_size=None,
display_mode_flags=None,
fps=None,
title=None,
):
self.state.clock = Clock()
self.state.is_running = False
self.state.window_size = tuple(window_size or GAME_DEFAULTS.WINDOW_SIZE)
self.state.fps = fps or GAME_DEFAULTS.FPS
self.state.title = title or GAME_DEFAULTS.TITLE
self.state.delta_t = None
self.state.display_mode_flags = (
reduce(lambda x, y: x | y, display_mode_flags)
if display_mode_flags and len(display_mode_flags) > 1
else (display_mode_flags or pg.DOUBLEBUF)
)
pg.init()
