def main():
"""Main program loop"""
pygame.init()
screen = pygame.display.set_mode(opt.window_size)
sys_font = Font(get_default_font(), opt.font_size)
clock = Clock()
manager = YarsManager()
running = True
while running:
#limit framerate and prepare FPS display text
clock.tick(opt.max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, opt.white)
if event.get(pygame.QUIT):
sys.exit()
running = manager.handle_events(event.get(), key.get_pressed())
manager.update()
screen.fill(opt.black)
manager.draw(screen)
screen.blit(fps_text, fps_text.get_rect(top = 0, right = opt.width))
pygame.display.update()
sys.exit()
def main():
"""The main function of the game.
Initializes PyGame objects and then enters the game loop
"""
pygame.init()
screen = pygame.display.set_mode(window_size)
sys_font = Font(get_default_font(), font_size)
clock = Clock()
#now that pygame is initialized, initialize inherited classes properly
global enemy_wave, player
enemy_wave = EnemyGroup(evil_bullets)
player = Player(window_size, ship_filename, ship_speed)
while 1:
#limit framerate and prepare FPS display text
clock.tick(max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, white)
score_text = sys_font.render("SCORE: {}".format(score), False, white)
lives_text = sys_font.render("MANS: {}".format(lives), False, white)
#check for QUIT event to prevent endless loopage
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
#call the game's thinking functions
check_gameover()
keyboard()
evil_bullets.update()
good_bullets.update()
enemy_wave.update()
collisions()
#draw the stuff
screen.fill(black)
good_bullets.draw(screen)
evil_bullets.draw(screen)
enemy_wave.draw(screen)
screen.blit(player.image, player.rect)
screen.blit(score_text, score_text.get_rect(top = 0, left = 0))
screen.blit(lives_text, lives_text.get_rect(top = 0, centerx = width / 2))
screen.blit(fps_text, fps_text.get_rect(top = 0, right = width))
pygame.display.update()
class Time(object):
"""
A helper class for dealing with time.
"""
_instance = None
def __init__(self):
if Time._instance is None:
Time._instance = self
else:
pass
self._delta_time = 0
self._time_scale = 1
self._clock = Clock()
def update(self):
self._delta_time = self._clock.tick(Configuration.instance().frame_cap )
@property
def delta_time(self):
return self._delta_time / self.time_scale
@property
def time_scale(self):
return self._time_scale
@time_scale.setter
def time_scale(self, time_scale):
self._time_scale = time_scale
@property
def clock(self):
return self._clock
@property
def frame_rate(self):
"""
:return: The frame rate which the game is current running.
"""
return self._clock.get_fps()
@staticmethod
def instance():
if Time._instance is None:
Time._instance = Time()
return Time._instance
class ClockController:
"""..."""
def __init__(self, event_manager):
self.event_manager = event_manager
self.event_manager.register_listener(self)
self._clock = Clock()
self.application_active = True
def run(self):
while self.application_active:
event = TickEvent(self._clock.tick(), self._clock.get_fps())
self.event_manager.post(event)
def notify(self, event):
if isinstance(event, QuitEvent):
# this will stop the while loop from running
self.application_active = False
class Game:
#Constants
#Properties
world = None
player = None
display = None
controls = None
clock = None
is_running = False
fps = -1
def __init__(self):
self.world = World()
self.display = Display()
self.controls = Controls()
self.clock = Clock()
self.fps = -1
#self.is_running = False ?
def init(self):
self.display.initWindow()
self.world.loadTextWorld('sample')
self.display.initMinimap(self.world)
self.player = Player(Vector(self.world.starting_point)+0.5)
def startLoop(self):
time_to_exit = False
while not time_to_exit:
self.clock.tick(30)
self.fps = self.clock.get_fps()
keys = self.controls.getInput()
self.player.move(self.world, keys)
self.display.draw(self)
time_to_exit = keys[self.controls.ESCAPE]
def close(self):
self.display.close()
import Camera
from pygame.time import Clock
running = True
paused = False
Game = Camera.Camera()
gameClock = Clock()
while running:
while not paused:
gameClock.tick(60)
fps = gameClock.get_fps()
Game.updateScreen(fps)
def run_game():
clock = Clock()
pygame.init()
pygame.font.init()
game_state = GS(GS.INVASION)
screen_state = ScS(ScS.NONE)
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Faceless Invasion")
# Make a player
player = Player(ai_settings, screen)
# Make a group to store daggers in
daggers = Group()
# Make a Faceless group
faceless_horde = Group()
# Create the horde of faceless
gf.create_horde(ai_settings, screen, player, faceless_horde)
black_screen = pygame.Surface(
(ai_settings.screen_width, ai_settings.screen_height))
black_screen.fill((0, 0, 0))
black_screen.set_alpha(0)
fade_alpha = 0
invasion_filename = 'images/Invasion Background.png'
invasion_background = pygame.image.load(invasion_filename)
invasion_background = pygame.transform.scale(
invasion_background,
(ai_settings.screen_width, ai_settings.screen_height))
shop_filename = 'images/Awakening Support Background.jpg'
shop_background = pygame.image.load(shop_filename)
shop_background = pygame.transform.scale(
shop_background, (ai_settings.screen_width, ai_settings.screen_height))
shop_menu = ShopMenu(screen_state, ai_settings)
while True:
clock.tick(ai_settings.fps)
# dt = clock.tick()
# print(dt)
gf.check_events(ai_settings, screen, player, daggers, game_state,
screen_state, shop_menu)
if game_state.get_state() == GS.INVASION or game_state.get_state(
) == GS.VICTORY:
player.update(ai_settings)
if game_state.get_state() == GS.INVASION:
daggers.update()
gf.update_daggers(ai_settings, screen, player, faceless_horde,
daggers, game_state)
gf.update_horde(ai_settings, faceless_horde)
if screen_state.get_state() == ScS.FADE_OUT:
if fade_alpha < 255:
fade_alpha += ai_settings.fade_speed
black_screen.set_alpha(fade_alpha)
elif fade_alpha >= 255:
if game_state.get_state() == GS.VICTORY:
game_state.set_state(GS.SHOP)
elif game_state.get_state() == GS.SHOP:
game_state.set_state(GS.INVASION)
gf.create_horde(ai_settings, screen, player,
faceless_horde)
screen_state.set_state(ScS.FADE_IN)
if screen_state.get_state() == ScS.FADE_IN:
if fade_alpha > 0:
fade_alpha -= ai_settings.fade_speed
black_screen.set_alpha(fade_alpha)
elif fade_alpha <= 0:
screen_state.set_state(ScS.NONE)
gf.update_screen(ai_settings, screen, player, faceless_horde, daggers,
black_screen, invasion_background, shop_background,
shop_menu, game_state, screen_state)
pygame.display.set_caption(
"FPS: %i Game State: %s Screen State: %s" %
(clock.get_fps(), game_state.get_name(), screen_state.get_name()))
class Scene:
'''
Describe a Scene in a game.
This is a base class for every scene in the game, has a main_loop
that can be called from the main process and the functions start and
update to controll the first and sucesives ticks respectively.
'''
def __init__(self, screen: Surface):
'''
Constructor of the class, takes the screen to gain control over
the render of the game objects
'''
# Get display info
info = Info()
# Get Clock to ensure frame rating
self.clock = Clock()
# The default return value of the Scene
self.return_value = -1
# Set the continue condition
self.running = True
# Get the relevant information from info
self.screen_h, self.screen_w = info.current_h, info.current_w
# Set the screen of the Scene
self.screen: Surface = screen
# Main Sprite groups
self.event_group = Group()
self.update_group = Group()
self.render_group = LayeredDirty()
def start(self):
'''
This function will is the first function called when the scene starts
running, here you can configure the position and starting behaviour of
your scene
'''
pass
def update(self):
'''
This function will be called every tick of the game and needs
to be overrided in every scene to fill the desired behaviour
'''
pass
def clear(self):
'''
This function will be called on the end of the scene to clean any
configuration or variables to the next scene.
It will raise NotImplementedError if it's not implemented, at least
needs a pass function if no work is needed
'''
raise NotImplementedError
def exit(self, return_value):
'''
This function will end the scene and return the value to the parent
'''
self.running = False
self.return_value = return_value
self.event_group.empty()
self.update_group.empty()
self.render_group.empty()
self.clear()
def main_loop(self):
'''
This is the main loop of the scene, don't overrive if not necesary.
Here you will find the main workflow for an scene
'''
# Ensures the starts conditions
self.running = True
self.return_value = -1
# Calls the start function, to configurate the scene
self.start()
# Main loop of the scene
while self.running:
# Event catch
# Set the event queue of the objet itself
self.events = []
for e in event.get():
self.events.append(e)
for s in self.event_group.sprites():
s.add_event(e)
if e.type == QUIT:
self.exit(-1)
# Group update
self.update_group.update(self.clock.get_time())
# Calls the update function for every tick of the game
self.update()
# Render group
self.render_group.draw(self.screen)
display.flip()
# Ensure frame rate
if DEBUG:
print(self.clock.get_fps())
self.clock.tick(60)
return self.return_value
class Game():
def __init__(self,
framerate=0,
surface_x=272,
surface_y=153,
scaler=4,
debug=True):
logging.info("Initializing game.")
self.framerate = framerate
if debug:
logging.warn("Game loading in debug mode.")
self.surface_x = surface_x * scaler
self.surface_y = surface_y * scaler
self.scaler = scaler
self.debug = debug
pygame.init()
self.main_surface = pygame.display.set_mode(
(self.surface_x, self.surface_y),
pygame.HWSURFACE | pygame.DOUBLEBUF)
self.clock = Clock()
self.state = GameState.INTRO
# self.font = pygame.font.Font(
# join('assets', 'font', 'Diary-of-an-8-bit-mage.woff'),
# 16)
# self.font = pygame.font.SysFont("Courier", 16)
self.font = pygame.font.Font(
join('assets', 'font', 'C&C-Red-Alert-[INET].ttf'), 16)
self.menue = Menue(self.main_surface, self.font)
self.background = assets.load.image("parallax-mountain-bg.png")
self.background = pygame.transform.scale(
self.background,
tuple(i * self.scaler for i in self.background.get_rect().size))
def run(self):
"""Start the game loop."""
while True:
self.clock.tick(self.framerate)
self.handle_events()
self.update_state()
self.display()
#print(self.clock.get_fps())
def handle_events(self):
"""Event handler.
Figures out what to do from the events it polled.
"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
if event.type == pygame.KEYDOWN:
if pygame.key.name(event.key) == 'escape':
if self.state == GameState.INTRO:
self.state = GameState.MAIN
elif self.state == GameState.PAUSED:
self.state = GameState.MAIN
elif self.state == GameState.MAIN:
self.state = GameState.PAUSED
print(pygame.key.name(event.key))
def intro(self):
self.main_surface.blit(self.background, (0, 0))
def update_state(self):
if self.state == GameState.INTRO:
self.intro()
if self.state == GameState.MAIN:
self.menue.draw('main')
if self.state == GameState.PAUSED:
self.menue.draw('paused')
if self.state == GameState.RUNNING:
pass
def display_fps(self):
fps_counter = "FPS: {0}".format(self.clock.get_fps())
fps_rendered = self.font.render(fps_counter, True, (0, 0, 0))
self.main_surface.blit(fps_rendered, (10, 10))
def display(self):
if self.debug:
self.display_fps()
pygame.display.flip()
def quit(self):
"""Handle all cleanup code."""
logging.info("Closing game.")
pygame.quit()
sys.exit()
class Game:
"""Object handling main loop and IO."""
def __init__(self, config):
pygame.mixer.pre_init(frequency=44100)
pygame.init()
self.headless = config.headless and config.server
if config.muted or self.headless:
pygame.mixer.quit()
else:
pygame.mixer.music.load(NOISE if config.space else MUSIC)
pygame.mixer.music.set_volume(config.musicvol)
pygame.mixer.music.play(-1)
pygame.display.set_icon(ICON)
if config.server:
self.server = socket()
self.server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.server.bind((config.host, config.port))
self.server.listen(1)
print('Socket server is listening on {}:{}'.format(config.host,
config.port))
self.timeout = config.timeout
self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 # freeze and point to NW
else:
self.server = self.sockinp = None
# self.fps is a float to make sure floordiv won't be used in Python 2
self.max_fps, self.fps = config.max_fps, float(config.max_fps)
self.musicvol = config.musicvol
self.key, self.mouse = config.key, config.mouse
self.maze = Maze(config.max_fps, config.size, config.headless,
config.export_dir, 1000.0 / config.export_rate)
self.hero = self.maze.hero
self.clock, self.paused = Clock(), False
def __enter__(self): return self
def export_txt(self):
"""Export maze data to string."""
export = self.maze.update_export(forced=True)
return '{} {} {} {}\n{}{}{}{}'.format(
len(export['m']), len(export['e']), len(export['b']), export['s'],
''.join(row + '\n' for row in export['m']), join(export['h']),
''.join(map(join, export['e'])), ''.join(map(join, export['b'])))
def update(self):
"""Draw and handle meta events on Pygame window.
Return False if QUIT event is captured, True otherwise.
"""
events = pygame.event.get()
for event in events:
if event.type == QUIT:
return False
elif event.type == VIDEORESIZE:
self.maze.resize((event.w, event.h))
elif event.type == KEYDOWN:
if event.key == self.key['mute']:
if pygame.mixer.get_init() is None:
pygame.mixer.init(frequency=44100)
pygame.mixer.music.load(MUSIC)
pygame.mixer.music.set_volume(self.musicvol)
pygame.mixer.music.play(-1)
else:
pygame.mixer.quit()
elif not self.server:
if event.key == self.key['new']:
self.maze.reinit()
elif event.key == self.key['pause'] and not self.hero.dead:
self.paused ^= True
# Compare current FPS with the average of the last 10 frames
new_fps = self.clock.get_fps()
if new_fps < self.fps:
self.fps -= 1
elif self.fps < self.max_fps and not self.paused:
self.fps += 5
if not self.paused: self.maze.update(self.fps)
if not self.headless: self.maze.draw()
self.clock.tick(self.fps)
return True
def move(self, x, y):
"""Command the hero to move faster in the given direction."""
maze = self.maze
velocity = maze.distance * HERO_SPEED / self.fps
accel = velocity * HERO_SPEED / self.fps
if x == y == 0:
maze.set_step()
x, y = maze.stepx, maze.stepy
else:
x, y = -x, -y # or move the maze in the reverse direction
if maze.next_move > 0 or not x:
maze.vx -= sign(maze.vx) * accel
if abs(maze.vx) < accel * 2: maze.vx = 0.0
elif x * maze.vx < 0:
maze.vx += x * 2 * accel
else:
maze.vx += x * accel
if abs(maze.vx) > velocity: maze.vx = x * velocity
if maze.next_move > 0 or not y:
maze.vy -= sign(maze.vy) * accel
if abs(maze.vy) < accel * 2: maze.vy = 0.0
elif y * maze.vy < 0:
maze.vy += y * 2 * accel
else:
maze.vy += y * accel
if abs(maze.vy) > velocity: maze.vy = y * velocity
def control(self, x, y, angle, firing, slashing):
"""Control how the hero move and attack."""
self.move(x, y)
self.hero.update_angle(angle)
self.hero.firing = firing
self.hero.slashing = slashing
def remote_control(self):
"""Handle remote control though socket server.
This function is supposed to be run in a Thread.
"""
clock = Clock()
while True:
connection, address = self.server.accept()
connection.settimeout(self.timeout)
time = get_ticks()
print('[{}] Connected to {}:{}'.format(time, *address))
self.maze.reinit()
while True:
if self.hero.dead:
connection.send('0000000'.encode())
break
data = self.export_txt().encode()
alpha = deg(self.hero.angle)
connection.send('{:07}'.format(len(data)).encode())
connection.send(data)
try:
buf = connection.recv(7)
except: # client is closed or timed out
break
if not buf: break
try:
move, angle, attack = map(int, buf.decode().split())
except ValueError: # invalid input
break
y, x = (i - 1 for i in divmod(move, 3))
# Time is the essence.
angle = self.hero.angle if angle == alpha else radians(angle)
self.sockinp = x, y, angle, attack & 1, attack >> 1
clock.tick(self.fps)
self.sockinp = 0, 0, -pi * 3 / 4, 0, 0
new_time = get_ticks()
print('[{0}] {3}:{4} scored {1} points in {2}ms'.format(
new_time, self.maze.get_score(), new_time - time, *address))
connection.close()
if not self.hero.dead: self.maze.lose()
def user_control(self):
"""Handle direct control from user's mouse and keyboard."""
if not self.hero.dead:
keys = pygame.key.get_pressed()
right = keys[self.key['right']] - keys[self.key['left']]
down = keys[self.key['down']] - keys[self.key['up']]
buttons = pygame.mouse.get_pressed()
try:
autove = keys[self.key['autove']]
except KeyError:
autove = buttons[self.mouse['autove']]
try:
firing = keys[self.key['shot']]
except KeyError:
firing = buttons[self.mouse['shot']]
try:
slashing = keys[self.key['slash']]
except KeyError:
slashing = buttons[self.mouse['slash']]
# Follow the mouse cursor
x, y = pygame.mouse.get_pos()
maze = self.maze
if right or down:
maze.destx = maze.desty = MIDDLE
maze.stepx = maze.stepy = 0
elif autove:
maze.destx, maze.desty = maze.get_grid(x, y)
maze.set_step(maze.is_displayed)
if maze.stepx == maze.stepy == 0:
maze.destx = maze.desty = MIDDLE
angle = atan2(y - self.hero.y, x - self.hero.x)
self.control(right, down, angle, firing, slashing)
def __exit__(self, exc_type, exc_value, traceback):
if self.server is not None: self.server.close()
if not self.hero.dead: self.maze.dump_records()
pygame.quit()
class StatusBar(object):
pausestring = _(u'*** PAUSED ***')
timestrings = [
_(u'\u2155 speed'),
_(u'\u00bd speed'),
_(u'Normal speed'),
_(u'2\u00d7 speed'),
_(u'5\u00d7 speed')
]
fpsstring = _(u'{num:d} {g}FPS')
def __init__(self, game, player, prefs):
self.game = game
player.history.setcrier(self._eventcrier)
self._prefs = prefs
self.sprites = LayeredDirty()
self.scale(self._prefs.font)
self.clock = Clock()
self.lasttime = None
self.fps = deque()
def _eventcrier(self, event):
text = event.description
contd = False
width = self.background.get_width()
while True:
try:
self.announcesprite.image = self.font.render(text +
('...' if contd
else ''),
True,
(255, 255, 255))
except error:
self.announcesprite.image = None
if (self.announcesprite.image and
self.announcesprite.image.get_width() < width):
break
words = text.split()
if len(words) == 1:
if len(words[0]) <= 1:
break
text = words[0][:-1]
contd = True
else:
text = ' '.join(words[:-1])
contd = True
self.announcesprite.rect = self.announcesprite.image.get_rect()
self.announcesprite.dirty = 1
self.announcesprite.time = time()
def _sprite(self, text, x, y, color = None):
color = color if color is not None else (255,255,255)
sprite = DirtySprite()
sprite.image = self.font.render(text, True, color)
sprite.rect = sprite.image.get_rect().move(x, y)
return sprite
def scale(self, font):
self.font = font
self.sprites.empty()
x = 0
self.announcesprite = self._sprite(' ', x, 0)
self.announcesprite.time = None
self.sprites.add(self.announcesprite)
y = self.announcesprite.rect.height
self.pausesprite = self._sprite(self.pausestring, x, y)
x += self.pausesprite.rect.width
self.timesprites = [self._sprite(t, x, y) for t in self.timestrings]
x += max([s.rect.width for s in self.timesprites])
self.fpssprites = [self._sprite(self.fpsstring.format(num=9999, g=g),
x, y)
for g in '','G']
self.fpssprites[1].rect.move_ip(self.fpssprites[1].rect.width, 0)
apply(self.sprites.add,
[self.pausesprite] + self.timesprites + self.fpssprites)
self._dirty()
def _dirty(self):
self.paused = None
self.timeindex = -1
def resize(self, size):
self.background = Surface(size, flags=SRCALPHA)
self.background.fill((0,0,0))
self._dirty()
def draw(self, surface):
t = time()
if (self.announcesprite.time and
t - self.announcesprite.time > self._prefs.announcementtimeout):
self.announcesprite.image.fill((0,0,0))
self.announcesprite.dirty = True
self.announcesprite.time = None
paused = self.game.paused
if self.paused != paused:
self.paused = paused
self.pausesprite.visible = self.paused
self.pausesprite.dirty = True
timeindex = self.game.timescales.index(0.1 / self.game.dt)
if self.timeindex != timeindex:
self.timeindex = timeindex
for i in range(len(self.timesprites)):
self.timesprites[i].visible = i == self.timeindex
self.timesprites[i].dirty = True
self.fps.clear()
if not self.lasttime:
self.lasttime = self.game.world.time, t
else:
if self.paused:
fps = 0
self.lasttime = self.game.world.time, t
else:
frames = self.game.world.time - self.lasttime[0]
secs = t - self.lasttime[1]
if secs > 0:
if len(self.fps) > 20:
self.fps.popleft()
self.fps.append(frames/secs)
fps = sum(self.fps)/len(self.fps)
else:
fps = None
self.lasttime = self.game.world.time, t
if fps is not None:
image = self.font.render(
self.fpsstring.format(num=int(fps+0.5), g=''),
True, (255,255,255))
self.fpssprites[0].image.fill((0,0,0))
self.fpssprites[0].image.blit(image,
(self.fpssprites[0].rect.width-
image.get_width(), 0))
self.fpssprites[0].dirty = True
image = self.font.render(
self.fpsstring.format(num=int(self.clock.get_fps()+0.5), g='G'),
True, (255,255,255))
self.fpssprites[1].image.fill((0,0,0))
self.fpssprites[1].image.blit(image,
(self.fpssprites[1].rect.width-
image.get_width(), 0))
self.fpssprites[1].dirty = True
self.sprites.clear(surface, self.background)
self.sprites.draw(surface)
self.clock.tick()
def Game_loop():
size = DISPLAY_WIDTH / 16.0
posx = (DISPLAY_WIDTH - (size // 2) * 17) * 27 // 100
posy = 0
court = generate_court(size=size, start_posx=posx, start_posy=posy)
snake = [(8, 18, 9), (8, 16, 8), (8, 14, 7)]
prey = 0
button_group = Group()
left_button = Text(text=u'<',
x=5,
y=50,
size=22,
font_file='a_Albionic.ttf',
color=(250, 250, 250),
surface=screen)
right_button = Text(text=u'>',
x=85,
y=50,
size=22,
font_file='a_Albionic.ttf',
color=(250, 250, 250),
surface=screen)
button_group.add(left_button, right_button)
menu_button = Hexagon_Button(lable=u'меню',
posx=87,
posy=2,
font_size=3,
font_file='a_Albionic.ttf',
color=(35, 125, 30),
text_color=(210, 205, 10),
border_color=(210, 205, 10))
wasted = Text(text=u'Потрачено!',
x=6,
y=35,
size=7,
font_file='a_Albionic.ttf',
color=(250, 150, 120),
surface=screen)
win = Text(text=u'Победа!',
x=20,
y=35,
size=14,
font_file='a_Albionic.ttf',
color=(250, 150, 120),
surface=screen)
points_label = Text(text=u'Очки: 0',
x=2,
y=2,
size=3,
font_file='a_Albionic.ttf',
color=(85, 170, 10),
surface=screen)
fps = Text(text=u'',
x=5,
y=2,
size=2,
font_file='a_Albionic.ttf',
color=(85, 170, 10),
surface=screen)
apple_eat_sound = mixer.Sound('sounds/Apple_eat.ogg')
apple_eat_sound.set_volume(1.0)
finally_background = Surface((DISPLAY_WIDTH, DISPLAY_HEIGHT))
vector = 1
alpha = 0
id = 8
x = 14
y = 7
dt = 0
clock = Clock()
done = False
while not done:
mp = mouse.get_pos()
for event in get():
if event.type == QUIT:
done = True
continue
if event.type == KEYDOWN:
if vector > 0:
if event.key == K_LEFT:
vector -= 1
if event.key == K_RIGHT:
vector += 1
if event.type == MOUSEBUTTONDOWN:
if vector > 0:
if left_button.rect.collidepoint(mp):
vector -= 1
elif right_button.rect.collidepoint(mp):
vector += 1
if menu_button.rect.collidepoint(mp):
done = True
continue
if vector < 1 and vector > -1:
vector = 6
elif vector > 6:
vector = 1
if not prey:
prey = choice(tuple(court))
while prey.id_and_pos in snake:
prey = choice(tuple(court))
if dt > 400:
dt = 0
if vector == 1:
x -= 2
y -= 1
elif vector == 2:
x -= 1
if x % 2 != 0:
y -= 1
id += 1
elif vector == 3:
x += 1
if x % 2 == 0:
y += 1
id += 1
elif vector == 4:
x += 2
y += 1
elif vector == 5:
x += 1
if x % 2 == 0:
y += 1
id -= 1
elif vector == 6:
x -= 1
if x % 2 != 0:
y -= 1
id -= 1
next_step = (id, x, y)
if next_step not in snake:
if prey.id_and_pos != next_step:
snake.append(next_step)
snake.pop(0)
else:
snake.append(next_step)
apple_eat_sound.play(0)
points_label.set_text(text=u'Очки: %s' %
str(len(snake) - 3))
prey = 0
#if len(snake) > 13:
# vector = -1
#delay(10)
else:
vector = -1
if id < 0 or id > 16 or y < 0 or y > 9:
vector = -1
screen.fill((20, 20, 40))
court.update(screen, snake, prey)
if vector == -1:
if alpha < 200:
alpha += 3
finally_background.set_alpha(alpha)
screen.blit(finally_background, (0, 0))
#if len(snake) < 12:
# wasted.draw()
#else:
# win.draw()
wasted.set_text(text=u'Уничтожено %s жертв!' % str(len(snake) - 3))
wasted.draw()
fps.set_text(u'FPS: %s' % clock.get_fps())
fps.draw()
button_group.draw(screen)
menu_button.draw(screen, mp)
points_label.draw()
window.blit(screen, (0, 0))
flip()
clock.tick(40)
dt += clock.get_tick()
class Instance:
log = Logger(__name__).get()
def __init__(self, caption: str = 'kappa game'):
pygame.init()
self.info = pygame.display.Info()
Instance.log.info(self.info)
self.caption: str = caption
self.clock: Clock = None
self.screen: Screen = None
self.running = True
self.max_fps = 0
def init(self):
self.clock = Clock()
pygame.display.set_caption(self.caption)
self.screen.init()
def start(self):
while self.running:
self.__tick()
def destroy(self):
if pygame.font.get_init():
pygame.font.quit()
pygame.quit()
@timed
def __tick(self):
self.clock.tick(self.max_fps)
self.__handle_events()
self.__update()
self.__display()
@timed
def __handle_events(self):
for event in pygame.event.get():
Instance.log.debug("Caught Event = {}".format(event))
if not self.parse_event(event):
self.running = False
def parse_event(self, event):
return 1
@timed
def __update(self):
self.update()
def update(self):
self.screen.update()
@timed
def __display(self):
self.screen.display()
pygame.display.flip()
Instance.log.debug("Current FPS : {}".format(self.fps))
@property
def fps(self):
return self.clock.get_fps()
def main():
pygame.init()
directory = Path(__file__).parent
font = Font(str(directory.joinpath("demo_font.dfont")), 13)
screen_size = (500, 500)
dialog_margin = 30
dialog_padding = 5
outer_dialog_size = (screen_size[0] - dialog_margin * 2, 330)
dialog_size = (outer_dialog_size[0] - dialog_padding * 2,
outer_dialog_size[1] - dialog_padding * 2)
picture_component_size = (dialog_size[0], 200)
screen = pygame.display.set_mode(screen_size)
dialog_surface = Surface(dialog_size)
dialog_pos = (dialog_margin + dialog_padding,
dialog_margin + dialog_padding)
dialog_rect = Rect(dialog_pos, dialog_size)
images = {
"demo1_background": filled_surface(picture_component_size, (0, 50, 35))
}
animations = {"demo1_animation": create_animation(picture_component_size)}
text_blip_sound = load_sound("blip.ogg")
select_blip_sound = load_sound("blip_2.ogg")
select_blip_sound_id = "blip"
sound_player = SoundPlayer(
sounds={select_blip_sound_id: select_blip_sound},
text_blip_sound=text_blip_sound)
dialog_closed_node_id = "DIALOG_CLOSED"
dialog_graph = DialogGraph(
root_node_id="ROOT",
nodes=[
DialogNode(
node_id="ROOT",
text=
"This is a minimal demo app. Let this text slowly appear or click any key to skip it. "
"Use the UP/DOWN keys to switch between your dialog choices, and click RETURN to go "
"for that choice. Or you could just use the mouse!",
choices=[
DialogChoice("See this dialog again", "ROOT"),
DialogChoice("Close dialog", dialog_closed_node_id)
],
graphics=NodeGraphics(animation_id="demo1_animation")),
DialogNode(node_id=dialog_closed_node_id,
text="",
choices=[],
graphics=NodeGraphics(animation_id="demo1_animation")),
],
title="DEMO 1",
background_image_id="demo1_background")
pygame.display.set_caption(dialog_graph.title)
dialog_component = DialogComponent(
surface=dialog_surface,
dialog_font=font,
choice_font=font,
images=images,
animations=animations,
sound_player=sound_player,
dialog_graph=dialog_graph,
picture_size=picture_component_size,
select_blip_sound_id=select_blip_sound_id)
clock = Clock()
is_dialog_shown = True
while True:
elapsed_time = Millis(clock.tick())
for event in pygame.event.get():
if event.type == pygame.QUIT:
_exit_game()
elif event.type == pygame.KEYDOWN:
if is_dialog_shown:
dialog_component.skip_text()
if event.key == pygame.K_RETURN:
dialog_component.commit_selected_choice()
if dialog_component.current_node_id(
) == dialog_closed_node_id:
is_dialog_shown = False
elif event.key == pygame.K_DOWN:
dialog_component.move_choice_selection(1)
elif event.key == pygame.K_UP:
dialog_component.move_choice_selection(-1)
elif event.type == pygame.MOUSEBUTTONDOWN:
ui_coordinates = translate_screen_to_ui_coordinates(
dialog_rect, pygame.mouse.get_pos())
if ui_coordinates:
dialog_component.commit_choice_at_position(ui_coordinates)
if dialog_component.current_node_id(
) == dialog_closed_node_id:
is_dialog_shown = False
elif event.type == pygame.MOUSEMOTION:
ui_coordinates = translate_screen_to_ui_coordinates(
dialog_rect, pygame.mouse.get_pos())
if ui_coordinates:
dialog_component.select_choice_at_position(ui_coordinates)
if is_dialog_shown:
dialog_component.update(elapsed_time)
dialog_component.redraw()
screen.fill(BLACK)
if is_dialog_shown:
screen.blit(dialog_component.surface, dialog_pos)
pygame.draw.rect(screen, (255, 100, 100),
Rect((dialog_margin, dialog_margin),
outer_dialog_size),
width=1)
fps_string = str(int(clock.get_fps())).rjust(3, ' ')
rendered_fps = font.render(f"FPS: {fps_string}", True, WHITE,
(0, 0, 0))
screen.blit(rendered_fps, (5, 5))
screen.blit(
font.render(
"The dialog library is confined to the red rectangle above.",
True, WHITE), (15, 400))
screen.blit(
font.render("This text is handled separately from the dialog.",
True, WHITE), (15, 430))
if not is_dialog_shown:
screen.blit(
font.render(
"Oops, you closed the dialog. Restart app to see it again.",
True, (255, 150, 150)), (15, 460))
pygame.display.update()
class Game:
"""Object handling main loop and IO."""
def __init__(self, config: ConfigReader):
pygame.init()
self.headless = config.headless and config.server
if not self.headless: pygame.display.set_icon(ICON)
self.actx = None if self.headless else Context(Device())
self._mute = config.muted
if config.server:
self.server = socket()
self.server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.server.bind((config.host, config.port))
self.server.listen(1)
print('Socket server is listening on {}:{}'.format(
config.host, config.port))
self.timeout = config.timeout
self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 # freeze and point to NW
else:
self.server = self.sockinp = None
self.max_fps, self.fps = config.max_fps, config.max_fps
self.musicvol = config.musicvol
self.touch = config.touch
self.key, self.mouse = config.key, config.mouse
self.maze = Maze(config.max_fps, config.size, config.headless,
config.export_dir, 1000 / config.export_rate)
self.hero = self.maze.hero
self.clock, self.paused = Clock(), False
def __enter__(self):
if self.actx is not None:
use_context(self.actx)
self.actx.listener.position = MIDDLE, -MIDDLE, 0
self.actx.listener.gain = not self._mute
self._source = play(SFX_NOISE)
self._source.looping = True
return self
def __exit__(self, exc_type, exc_value, traceback):
if self.server is not None: self.server.close()
if not self.hero.dead: self.maze.dump_records()
if self.actx is not None:
free(SFX)
self._source.stop()
self.actx.update()
use_context(None)
self.actx.destroy()
self.actx.device.close()
pygame.quit()
@property
def mute(self):
"""Mute state."""
return getattr(self, '_mute', 1)
@mute.setter
def mute(self, value):
"""Mute state."""
self._mute = int(bool(value))
self.actx.listener.gain = not self._mute
def export_txt(self):
"""Export maze data to string."""
export = self.maze.update_export(forced=True)
return '{} {} {} {}\n{}{}{}{}'.format(
len(export['m']), len(export['e']), len(export['b']),
export['s'], ''.join(row + '\n' for row in export['m']),
join(export['h']), ''.join(map(join, export['e'])),
''.join(map(join, export['b'])))
def update(self):
"""Draw and handle meta events on Pygame window.
Return False if QUIT event is captured, True otherwise.
"""
events = pygame.event.get()
for event in events:
if event.type == QUIT:
return False
elif event.type == VIDEORESIZE:
self.maze.resize((event.w, event.h))
elif event.type == KEYDOWN:
if event.key == self.key['mute']:
self.mute ^= 1
elif not self.server:
if event.key == self.key['new']:
self.maze.reinit()
elif event.key == self.key['pause'] and not self.hero.dead:
self.paused ^= True
elif event.type == MOUSEBUTTONUP and self.touch:
# We're careless about which mouse button is clicked.
maze = self.maze
if self.hero.dead:
maze.reinit()
else:
x, y = pygame.mouse.get_pos()
maze.destx, maze.desty = maze.get_grid(x, y)
if maze.set_step(maze.isdisplayed):
maze.target = maze.get_target(x, y)
self.hero.firing = not maze.target.retired
if maze.stepx == maze.stepy == 0:
maze.destx = maze.desty = MIDDLE
# Compare current FPS with the average of the last 10 frames
new_fps = self.clock.get_fps()
if new_fps < self.fps:
self.fps -= 1
elif self.fps < self.max_fps and not self.paused:
self.fps += 5
if not self.paused: self.maze.update(self.fps)
if not self.headless: self.maze.draw()
self.clock.tick(self.fps)
self.actx.update()
return True
def move(self, x=0, y=0):
"""Command the hero to move faster in the given direction."""
maze = self.maze
velocity = maze.distance * HERO_SPEED / self.fps
accel = velocity * HERO_SPEED / self.fps
if x == y == 0:
maze.set_step()
x, y = maze.stepx, maze.stepy
else:
x, y = -x, -y # or move the maze in the reverse direction
if maze.next_move > 0 or not x:
maze.vx -= sign(maze.vx) * accel
if abs(maze.vx) < accel * 2: maze.vx = 0.0
elif x * maze.vx < 0:
maze.vx += x * 2 * accel
else:
maze.vx += x * accel
if abs(maze.vx) > velocity: maze.vx = x * velocity
if maze.next_move > 0 or not y:
maze.vy -= sign(maze.vy) * accel
if abs(maze.vy) < accel * 2: maze.vy = 0.0
elif y * maze.vy < 0:
maze.vy += y * 2 * accel
else:
maze.vy += y * accel
if abs(maze.vy) > velocity: maze.vy = y * velocity
def control(self, x, y, angle, firing, slashing):
"""Control how the hero move and attack."""
self.move(x, y)
self.hero.update_angle(angle)
self.hero.firing = firing
self.hero.slashing = slashing
def remote_control(self):
"""Handle remote control though socket server.
This function is supposed to be run in a Thread.
"""
clock = Clock()
while True:
connection, address = self.server.accept()
connection.settimeout(self.timeout)
time = get_ticks()
print('[{}] Connected to {}:{}'.format(time, *address))
self.maze.reinit()
while True:
if self.hero.dead:
connection.send('0000000'.encode())
break
data = self.export_txt().encode()
alpha = deg(self.hero.angle)
connection.send('{:07}'.format(len(data)).encode())
connection.send(data)
try:
buf = connection.recv(7)
except: # client is closed or timed out
break
if not buf: break
try:
move, angle, attack = map(int, buf.decode().split())
except ValueError: # invalid input
break
y, x = (i - 1 for i in divmod(move, 3))
# Time is the essence.
angle = self.hero.angle if angle == alpha else radians(angle)
self.sockinp = x, y, angle, attack & 1, attack >> 1
clock.tick(self.fps)
self.sockinp = 0, 0, -pi * 3 / 4, 0, 0
new_time = get_ticks()
print('[{0}] {3}:{4} scored {1} points in {2}ms'.format(
new_time, self.maze.get_score(), new_time - time, *address))
connection.close()
if not self.hero.dead: self.maze.lose()
def touch_control(self):
"""Handle touch control."""
maze, hero = self.maze, self.hero
if maze.target.retired: hero.firing = False
if hero.firing:
x, y = maze.get_pos(maze.target.x, maze.target.y)
else:
x, y = pygame.mouse.get_pos()
hero.update_angle(atan2(y - hero.y, x - hero.x))
self.move()
def user_control(self):
"""Handle direct control from user's mouse and keyboard."""
if self.hero.dead: return
keys = pygame.key.get_pressed()
buttons = pygame.mouse.get_pressed()
right = keys[self.key['right']] - keys[self.key['left']]
down = keys[self.key['down']] - keys[self.key['up']]
x, y = pygame.mouse.get_pos()
angle = atan2(y - self.hero.y, x - self.hero.x)
try:
firing = keys[self.key['shot']]
except KeyError:
firing = buttons[self.mouse['shot']]
try:
slashing = keys[self.key['slash']]
except KeyError:
slashing = buttons[self.mouse['slash']]
self.control(right, down, angle, firing, slashing)
class Application(object):
"""
@type _config: configparser.ConfigParser
@type _display: pygame.Surface
@type _manager: Manager
@type _scene: AbstractScene
@type _clock: Clock
@type _camera: Camera
@type _run: bool
@type _state: int
"""
_config = None
_display = None
_manager = None
_scene = None
_clock = None
_camera = None
_state = GAME_STATE_LOADING
_run = False
def __init__(self, config):
"""
@type config: configparser.ConfigParser
"""
self._config = config
self._manager = Manager(self)
pygame.mixer.init()
pygame.init()
def init(self):
config_display = self._config["DISPLAY"]
display_width = int(config_display.get("width", 800))
display_height = int(config_display.get("height", 600))
display_tup = (display_width, display_height)
pygame.init()
fullscreen = int(config_display.get("fullscreen", 0))
display_flags = DOUBLEBUF | HWSURFACE
if fullscreen == 1:
display_flags |= FULLSCREEN
videoinfo = pygame.display.Info()
# we have to limit our display to FullHD, to use only one monitor untill pygame with SDL > 1.2.14 released
display_tup = (min(videoinfo.current_w, 1920), min(videoinfo.current_h, 1080))
self._display = pygame.display.set_mode(display_tup, display_flags)
self._camera = Camera(self._display.get_size())
self._clock = Clock()
self.set_scene(self._manager.get_scene(MainMenuScene))
def get_display(self):
return self._display
def get_camera(self):
return self._camera
def set_state(self, state):
"""
@type state: int
"""
self._state = state
def get_state(self):
return self._state
def set_scene(self, scene: AbstractScene):
self._scene = scene
def running(self):
return bool(self._run)
def run(self, run=False):
self._run = run
while self.running():
events = pygame.event.get()
for e in events:
if e.type == EVENT_LOAD_MAP:
camera = self._manager.get_camera()
map_loading_thread = slg.map.map.MapLoadingThread(
e.map_name, slg.map.map.Map(self._manager), camera
)
map_loading_thread.start()
if e.type == QUIT:
self._run = False
if e.type == KEYDOWN:
if e.key == K_F4 and pygame.key.get_mods() & pygame.KMOD_ALT:
self._run = False
if e.key == K_t and pygame.key.get_mods() & pygame.KMOD_ALT:
print(self.get_state())
self._manager.handle(events)
if self._scene:
self._scene.handle_events(events)
self._scene.draw()
pygame.display.update()
pygame.display.set_caption(
"FPS: %.2f" % (self._clock.get_fps()) + "ticks: %.2f" % (self._clock.tick(FPS))
)
def get_time(self):
return self._clock.get_time()
class Camera():
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 set_window(self, window):
self.window = window
def is_shooting(self):
# print(self.shots, self.remaining_shots, self.made_comic_strip, self.comic_strip)
if self.shots and not self.remaining_shots and (
self.made_comic_strip or not self.comic_strip):
return False
else:
return True
def indexes(self):
if type(self.shots) == int:
return range(0, self.shots)
else:
return range(0, len(self.shots))
def make_comic_strip(self):
# https://stackoverflow.com/questions/30227466/combine-several-images-horizontally-with-python
import sys
from PIL import Image
image_files = [
os.path.join(self.dir, self.name + str(idx) + ".png")
for idx in self.indexes()
]
images = list(map(Image.open, image_files))
width, height = images[0].size
total_width = width * self.comic_strip
max_height = height * int(ceil(len(images) / float(self.comic_strip)))
new_im = Image.new('RGB', (total_width, max_height))
for i, im in enumerate(images):
x_offset = (i % self.comic_strip) * width
y_offset = (i // self.comic_strip) * height
# print('offsets',(x_offset,y_offset))
new_im.paste(im, (x_offset, y_offset))
new_im.save(os.path.join(self.dir, self.name + '_comic_strip.png'))
self.made_comic_strip = True
def should_shoot(self):
if type(self.remaining_shots) == int:
return self.get_fps() > 0 and (self.remaining_shots > 0)
else:
return (self.remaining_shots
and self.total_ticks >= self.remaining_shots[0])
def shoot(self):
if type(self.remaining_shots) == int:
idx = self.shots - self.remaining_shots
self.remaining_shots = self.remaining_shots - 1
else:
idx = self.shots.index(self.remaining_shots[0])
self.remaining_shots.pop(0)
# print('taking shot', idx)
image_name = os.path.join(self.dir, self.name + str(idx) + ".png")
save(self.window, image_name)
def tick(self):
res = self.clock.tick()
self.total_ticks += res
# print("tick", self.total_ticks, self.remaining_shots)
if self.should_shoot():
self.shoot()
elif self.comic_strip and not self.made_comic_strip and not self.remaining_shots:
# print('making comic strip')
self.make_comic_strip()
return res
def get_fps(self):
return self.clock.get_fps()
if collision_pnt:
e1.collide(e2.id, collision_pnt)
e2.collide(e1.id, collision_pnt)
entity_control.kill_finalize()
player = entity_control.entity_dict[player_id]
camera.set_pos(player.pos-player.velocity*delta)
#draw loop
draw_list = Draw_Call_List()
for e in entity_control.yield_entities():
draw_list.append(e.draw(debug))
draw_list.draw()
draw.draw_text(str(clock/1000.0), (0,0), 255, 255, 255)
draw.draw_text(str(fps_clock.get_fps()), (40,0), 255, 255, 255)
draw.draw_text(str(map(int, player.pos.tuple())), (0,30), 255, 255, 255)
draw.draw_text(str(input.player_move), (0,15), 255, 255, 255)
delta = fps_clock.get_time()
fps_clock.tick()
draw.flip()
pygame.quit()
class Visualization:
def __init__(self, engine):
self.running = True
self.display_surf = None
self.size = self.width, self.height = 800, 600
self.center = self.width / 2, self.height / 2
self.clock = Clock()
self.font = None
self.engine = engine
self.engine.on_simulation_step = self.build_scene
self.scene = []
self.target_fps = 60.0
self.focused_car = 0
self.metadata = []
def on_init(self):
pygame.init()
pygame.font.init()
self.display_surf = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
self.running = True
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.sprites = [
Sprite("images/blue-small.png"),
Sprite("images/orange-small.png"),
]
self.engine.restart()
def build_scene(self, engine):
self.scene = []
self.metadata = []
# if there are no cars break
if not self.engine.cars or len(self.engine.cars) == 0:
self.scene.append((self.center, 0, self.sprites[0]))
return
if self.focused_car >= len(self.engine.cars):
self.focused_car = 0
center = self.engine.cars[self.focused_car].position
for idx, car in enumerate(self.engine.cars):
car_pos = self.center - (center - car.position) * meter2pixel
self.scene.append(
(car_pos, car._angle, self.sprites[idx % len(self.sprites)]))
self.metadata.append(((int(car_pos.x), int(car_pos.y)), 0))
# for v in car.vertices():
# relpos = self.center - (center-v) * meter2pixel
# self.metadata.append((relpos.astype(np.int), 1))
if car == self.engine.cars[self.focused_car]:
for s in car._sensors:
if isinstance(s, LidarSensor):
for v in s._intersections:
if v is not None:
relpos = self.center - (center -
v) * meter2pixel
self.metadata.append(
(relpos.astype(np.int), 1))
def on_event(self, event):
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN:
pressed = pygame.key.get_pressed()
if pressed[pygame.K_ESCAPE]:
self.running = False
if pressed[pygame.K_SPACE]:
if self.engine.is_running:
self.engine.interrupt()
else:
self.engine.run()
if pressed[pygame.K_x]:
self.engine.restart()
if pressed[pygame.K_TAB]:
self.move_focus()
def move_focus(self):
self.focused_car += 1
self.build_scene(self.engine)
def on_loop(self):
pass
def on_render(self):
self.display_surf.fill(pygame.Color(0, 0, 0))
for pos, angle, sprite in self.scene:
rotated = pygame.transform.rotate(sprite.image, angle)
rect = rotated.get_rect()
relpos = pos - (rect.width / 2, rect.height / 2)
self.display_surf.blit(rotated, relpos)
for pos, typ in self.metadata:
if typ == 0:
pygame.draw.circle(self.display_surf, (255, 0, 0), pos, 3)
if typ == 1:
pygame.draw.circle(self.display_surf, (0, 255, 0), pos, 3)
# FPS writing
fps_surface = self.font.render(
"{:.0f} FPS".format(self.clock.get_fps()), True, (255, 255, 255))
self.display_surf.blit(
fps_surface,
(self.display_surf.get_width() - fps_surface.get_width(), 0))
# Simulation steps writing
step_surface = self.font.render(
"{} steps".format(self.engine.step_count), True, (255, 255, 255))
self.display_surf.blit(
step_surface,
(self.display_surf.get_width() - step_surface.get_width(),
fps_surface.get_height() + 5))
# Simulation control keys
lines = '''SPACE - start/stop simulation
X - restart simulation
TAB - move focus
ESC - quit'''
y = 5
for line in lines.split('\n'):
text = self.font.render(line.strip(), True, (255, 255, 255))
self.display_surf.blit(text, (5, y))
y += 5 + text.get_height()
pygame.display.flip()
self.clock.tick(self.target_fps)
def on_cleanup(self):
pygame.quit()
def on_execute(self):
if self.on_init() == False:
self.running = False
while (self.running):
for event in pygame.event.get():
self.on_event(event)
self.on_loop()
self.on_render()
self.on_cleanup()
def main():
pygame.init()
screen = pygame.display.set_mode(SCREEN_RESOLUTION)
clock = Clock()
set_timer(USEREVENT_EACH_SECOND, 1000)
font = Font('resources/Arial Rounded Bold.ttf', 14)
background_color = (0, 0, 0)
grid = BackgroundGrid(SCREEN_RESOLUTION, Color(20, 20, 20), 32)
fps_text = FormattedText(font, COLOR_WHITE, "FPS: %i", 0)
debug_texts = [
fps_text,
StaticText(font, COLOR_WHITE, "debug: 2"),
StaticText(font, COLOR_WHITE, "debug: 3"),
]
debug_window = ListContainer(width=200,
height="fit_contents",
children=debug_texts,
margin=5,
padding=5,
orientation=Orientation.VERTICAL,
style=Style(border_color=COLOR_WHITE))
left_buttons = [
button(font, (200, 48), callback=lambda: print("hello"),
label="click"),
button(font, (200, 48), callback=lambda: print("hello"),
label="click"),
button(font, (200, 48), callback=lambda: print("hello"),
label="click"),
]
counter = Counter((50, 50),
FormattedText(font, COLOR_WHITE, "%i", 0),
style=Style(background_color=Color(100, 100, 100)))
right_buttons = [
button(font, (200, 32),
callback=lambda: counter.increment(),
label="Increment (I)",
hotkey=pygame.K_i),
button(font, (200, 32),
callback=lambda: counter.decrement(),
label="Decrement (D)",
hotkey=pygame.K_d),
checkbox(font, (200, 32),
callback=lambda checked: debug_window.set_visible(checked),
label="Show debug",
checked=debug_window.is_visible()),
checkbox(font, (200, 32),
callback=lambda checked: print("B: %s" % checked),
label="B"),
checkbox(font, (200, 32),
callback=lambda checked: print("C: %s" % checked),
label="C"),
checkbox(font, (200, 32),
callback=lambda checked: print("D: %s" % checked),
label="D"),
checkbox(font, (200, 32),
callback=lambda checked: print("E: %s" % checked),
label="E"),
checkbox(font, (200, 32),
callback=lambda checked: print("F: %s" % checked),
label="F"),
]
left_menu_bar = ListContainer(width="fit_contents",
height="fill_parent",
children=left_buttons,
margin=5,
padding=5,
orientation=Orientation.VERTICAL,
style=Style(background_color=Color(
150, 150, 255),
border_color=COLOR_WHITE))
right_menu_bar = ScrollContainer(height=166,
children=right_buttons,
margin=5,
padding=5,
orientation=Orientation.VERTICAL,
style=Style(background_color=Color(
150, 210, 255),
border_color=COLOR_WHITE))
text_field = TextArea(font,
COLOR_WHITE, (100, 100),
padding=5,
style=Style(border_color=COLOR_WHITE))
icon_background = load_and_scale_image('resources/stone_tile.png',
(32, 32))
grid_children = [
number_button(font, text_field, "1", pygame.K_1),
number_button(font, text_field, "2", pygame.K_2),
number_button(font, text_field, "3", pygame.K_3),
number_button(font, text_field, "4", pygame.K_4),
number_button(font, text_field, "5", pygame.K_5),
number_button(font, text_field, "6", pygame.K_6),
icon(font, (32, 32), icon_background, "A", pygame.K_a),
icon(font, (32, 32), icon_background, "B", pygame.K_b),
icon(font, (32, 32), icon_background, "C", pygame.K_c),
number_button(font, text_field, "0", pygame.K_0),
backspace_button(font, text_field)
]
grid_container = GridContainer(children=grid_children,
dimensions=(3, 4),
padding=5,
margin=2,
style=Style(background_color=Color(
150, 130, 100),
border_color=COLOR_WHITE))
img = image_surface('resources/stone_tile.png', (100, 100))
hud = ListContainer(
width=800,
height=200,
children=[right_menu_bar, counter, grid_container, text_field, img],
margin=5,
padding=5,
orientation=Orientation.HORIZONTAL,
style=Style(border_color=COLOR_WHITE,
background_color=Color(0, 0, 150)))
container = AbsolutePosContainer(SCREEN_RESOLUTION,
[(Vector2(5, 5), debug_window),
(Vector2(0, 400), hud)])
container.set_pos(Vector2(0, 0))
while True:
for event in pygame.event.get():
handle_exit(event)
if event.type == pygame.MOUSEBUTTONDOWN:
container.handle_mouse_was_clicked(pygame.mouse.get_pos())
elif event.type == pygame.MOUSEBUTTONUP:
container.handle_mouse_was_released()
elif event.type == pygame.MOUSEMOTION:
container.handle_mouse_motion(pygame.mouse.get_pos())
elif event.type == USEREVENT_EACH_SECOND:
fps_text.format_text(int(clock.get_fps()))
elif event.type == pygame.KEYDOWN:
container.handle_key_was_pressed(event.key)
elif event.type == pygame.KEYUP:
container.handle_key_was_released(event.key)
elapsed_time = clock.tick()
container.update(elapsed_time)
screen.fill(background_color)
grid.render(screen)
container.render(screen)
pygame.display.flip()
class Loop:
def __init__(self, util: Util, cfg: Config, sfx: SfxHolder, txt: Text,
drawer: Drawer):
self.util = util
self.cfg = cfg
self.sfx = sfx
self.txt = txt
self.drawer = drawer
self.clock = Clock()
def main(self, screen, game: Game) -> bool:
# Dump first tick to ignore past
self.clock.tick(self.cfg.frames_per_second)
while True:
# Get change in time
dt = self.clock.tick(self.cfg.frames_per_second)
# Loop over events (quit, key down, key up)
for event in pg.event.get():
if user_quit(event):
return False
elif event.type == pg.KEYDOWN:
if event.key in self.cfg.all_keys:
game.press_key(event.key)
elif event.type == pg.KEYUP:
if event.key in self.cfg.all_keys:
game.release_key(event.key)
# Move and draw game (with possible paused screen and fps)
if not game.paused:
game.move(dt)
if not game.game_over:
self.drawer.draw_game(screen, game, dt)
if game.paused:
self.drawer.draw_paused_overlay(screen)
if self.cfg.draw_fps:
self.drawer.draw_fps(screen, self.clock.get_fps())
# Update display
pg.display.update()
# Break if game no longer running
if game.game_over:
return True
def game_over(self, screen, game: Game, scores: ScoresList) -> bool:
score_saved = False # not saved yet
self.sfx.game_over.play() # play audio
i = 0
while True:
# Fade-in game over screen
if i < 256:
pg.event.get() # dummy get
self.drawer.draw_game(screen, game, 0) # draw game
self.drawer.draw_game_over_overlay(
screen, i, score_saved) # fade-in game over screen
self.clock.tick(60) # slow-down the fade-in
# Refresh screen
pg.display.flip()
i += 1
# Check for quit or restart events
for event in pg.event.get():
if user_quit(event):
return False
elif event.type == pg.MOUSEBUTTONDOWN:
if self.txt.restart_rect.collidepoint(*event.pos):
return True
elif not score_saved and \
self.txt.save_score_rect.collidepoint(*event.pos):
for score in game.get_scores():
scores.add_score(score)
scores.write()
score_saved = True
elif i > new_value:
i = max(i-INCREMENTS_PER_FRAME, new_value) # If we're taking away power, clip the result to the new value
print(str(i)+"\r", end=" ")
kit.continuous_servo[pi_mapping[control]].throttle = i
last_values[control] = i
clock = Clock()
def apply_continue():
global controls_dict
while True:
apply_controls(controls_dict)
clock.tick(FRAMERATE)
motor_thread = Thread(target=apply_continue)
motor_thread.start()
fps = 0
while True:
data, from_address = sock.recvfrom(4096)
controls = data.decode().split(";")[-2]
if len(controls) > 0:
#print(controls)
eval(controls) # Get the last command, evaluate it, and apply the controls
fps = clock.get_fps()
