class Record():
def __init__(self, parent):
self.parent = parent
self.ui = UI(self.parent.lcd)
self.ui.add_text('title', 10, 10, 'Record')
self.ui.add_text('recording', 200, 10, 'Stop')
self.ui.add_text('date', 20, 50, '2020/8/22')
self.ui.add_text('ax', 20, 50 + 40, '999')
self.ui.add_text('ay', 20, 50 + 80, '999')
self.ui.add_text('az', 20, 50 + 120, '999')
def control(self, button):
if button['left']:
self.parent.state = 'home'
if button['right']:
self.parent.state = 'settings'
self.mpu9250()
def draw(self):
self.ui.draw()
def mpu9250(self):
accel = self.parent.mpu9250.read_accel()
#gyro = self.parent.mpu9250.read_gyro()
#mag = self.parent.mpu9250.read_magnet()
self.ui.texts['ax'].set_text(str(accel['x']))
self.ui.texts['ay'].set_text(str(accel['y']))
self.ui.texts['az'].set_text(str(accel['z']))
class Game:
def __init__(self):
self.hasStarted = False
self.hasDied = False
self.highScore = 0
self.reset()
def reset(self):
self.cam = Camera()
self.world = World(self.cam)
self.ui = UI(self.world)
self.player = Player(self.world, self.onPlayerDead)
self.world.player = self.player
self.inventory = Inventory()
self.inventory.player = self.player
def update(self):
keys = pygame.key.get_pressed()
if not self.hasStarted:
if keys[pygame.K_RETURN]:
self.hasStarted = True
if self.hasDied:
if keys[pygame.K_RETURN]:
self.reset()
self.hasDied = False
if self.hasDied or not self.hasStarted:
return
self.player.update()
self.cam.move(game.player)
self.inventory.update()
self.world.update(game.cam)
def render(self, DISPLAYSURF):
self.world.render(DISPLAYSURF, game.cam)
if not self.hasStarted:
self.ui.renderStartingScreen(DISPLAYSURF)
elif self.hasDied:
self.ui.renderDiedScreen(DISPLAYSURF, self.highScore)
else:
self.inventory.render(DISPLAYSURF)
self.ui.draw(DISPLAYSURF)
def onPlayerDead(self):
self.hasDied = True
self.highScore = max(self.player.score, self.highScore)
class Settings():
def __init__(self, parent):
self.parent = parent
self.ui = UI(self.parent.lcd)
self.ui.add_text('title', 10, 10, 'Settings')
self.ui.add_button('button1', 20, 50, 'Bluetooth')
self.ui.add_button('button2', 20, 90, 'Tire size')
self.ui.add_button('button3', 20, 130, 'Time')
self.ui.buttons['button1'].selected = True
def control(self, button):
if button['left']:
self.parent.state = 'record'
if button['right']:
self.parent.state = 'home'
if button['up']:
self.button_select(1)
if button['down']:
self.button_select(-1)
def draw(self):
self.ui.draw()
def button_select(self, direction):
keys = list(self.ui.buttons.keys())
for n, key in enumerate(keys):
if self.ui.buttons[key].selected:
self.ui.buttons[key].selected = False
break
if direction > 0:
if n == len(keys):
self.ui.buttons[keys[0]].selected = True
return
if direction < 0:
if n == 0:
self.ui.buttons[keys[-1]].selected = True
return
self.ui.buttons[keys[n + direction]].selected = True
return
import ure as re
import picoweb
from ui import UI
import network
from gc import collect
collect()
sta_if = network.WLAN(network.STA_IF)
ifconfig = sta_if.ifconfig()
print('Start UI')
ui = UI()
ui.cls()
ui.draw()
def index(req, resp):
# You can construct an HTTP response completely yourself, having
# a full control of headers sent...
yield from resp.awrite("HTTP/1.0 200 OK\r\n")
yield from resp.awrite("Content-Type: text/html\r\n")
yield from resp.awrite("\r\n")
yield from resp.awrite(
"I can show you a table of <a href='squares'>squares</a>.<br/>")
yield from resp.awrite("Or my <a href='file'>source</a>.")
yield from resp.awrite(ifconfig[0])
def squares(req, resp):
# Or can use a convenience function start_response() (see its source for
# extra params it takes).
yield from picoweb.start_response(resp)
class MainView:
def __init__(self):
fileConfig('log.conf')
self.logger = logging.getLogger(type(self).__name__)
self.resolution = np.array([800, 450])
self.target_fps = 60
self.frame_render_time = 1 / self.target_fps
self.init_window()
self.get_gl_info()
self.init_shader()
self.init_camera()
self.main_loop()
def get_gl_info(self):
self.logger.info('Vendor : {}'.format(
glGetString(GL_VENDOR).decode()))
self.logger.info('Renderer : {}'.format(
glGetString(GL_RENDERER).decode()))
self.logger.info('Version : {}'.format(
glGetString(GL_VERSION).decode()))
self.logger.info('SL Version: {}'.format(
glGetString(GL_SHADING_LANGUAGE_VERSION).decode()))
#self.logger.debug('Extensions: {}'.format(glGetString(GL_EXTENSIONS).decode()))
def get_shader_time(self):
return os.path.getmtime('shaders/shader.frag')
def init_shader(self):
self.shader = Shader({
GL_VERTEX_SHADER: 'shaders/shader.vert',
GL_GEOMETRY_SHADER: 'shaders/shader.geom',
GL_FRAGMENT_SHADER: 'shaders/shader.frag'
})
self.shader.create()
self.shader_time = self.get_shader_time()
self.freeze_time = False
self.time = 0.
self.logger.debug('Shader program initialized')
def init_camera(self):
self.camera = Camera(self)
def init_window(self):
glfw.init()
self.window = glfw.create_window(*self.resolution, 'PyGL', None, None)
glfw.make_context_current(self.window)
glfw.set_window_size_callback(self.window, self.resize)
glfw.set_key_callback(self.window, self.keyboard_input)
glfw.set_scroll_callback(self.window, self.scroll_input)
glfw.set_cursor_pos_callback(self.window, self.mouse_position_input)
glClearColor(0, 0, 0, 1)
self.target_frame_time = 1 / self.target_fps
self.ui = UI(self)
self.logger.debug('Window initialized')
def resize(self, win, width, height):
#self.logger.debug('Window resized: {}x{}'.format(width, height))
self.resolution = np.array([width, height])
glViewport(0, 0, *self.resolution)
def keyboard_input(self, win, key, scancode, action, mods):
#self.logger.debug('key: {}, scancode: {}, action: {}, mods: {}'.format(key, scancode, action, mods))
if (key == glfw.KEY_ESCAPE
) or (mods == glfw.MOD_ALT
and key == glfw.KEY_F4) and action == glfw.PRESS:
glfw.set_window_should_close(self.window, True)
self.logger.info('Exiting')
if key == glfw.KEY_H and action == glfw.PRESS:
self.ui.toggle_visibility()
self.logger.debug('Toggle UI')
if key == glfw.KEY_W and action != glfw.RELEASE:
self.camera.move_forward()
if key == glfw.KEY_A and action != glfw.RELEASE:
self.camera.move_left()
if key == glfw.KEY_S and action != glfw.RELEASE:
self.camera.move_backward()
if key == glfw.KEY_D and action != glfw.RELEASE:
self.camera.move_right()
if key == glfw.KEY_Q and action != glfw.RELEASE:
self.camera.move_up()
if key == glfw.KEY_E and action != glfw.RELEASE:
self.camera.move_down()
if key == glfw.KEY_R and action == glfw.PRESS:
self.camera.reset()
if key == glfw.KEY_P and action == glfw.PRESS:
self.freeze_time = not self.freeze_time
self.logger.info('Toggle time freeze')
if key == glfw.KEY_F and action == glfw.PRESS:
self.camera.toggle_look_mode()
self.logger.info('Toggle camera look mode')
if key == glfw.KEY_T and action == glfw.PRESS:
self.ui.toggle_composition_overlay()
self.logger.info('Toggle composition overlay')
def scroll_input(self, win, x, y):
if y > 0:
self.camera.accelerate()
elif y < 0:
self.camera.decelerate()
def mouse_position_input(self, win, x, y):
if self.camera.look_mode:
self.camera.look(x, y)
def wait_for_frame_end(self, frame_start_time):
frame_render_time = glfw.get_time() - frame_start_time
#self.logger.debug('Frame render time: {:.1f} ms ({:.1f}%)'.format(1000*frame_render_time, frame_render_time/self.target_frame_time*100))
self.frame_render_time = frame_render_time
sleep_time = self.target_frame_time - frame_render_time
if sleep_time > 0:
time.sleep(sleep_time)
def check_for_shader_change(self):
current_time = self.get_shader_time()
if current_time != self.shader_time:
self.shader_time = current_time
self.shader.create()
def main_loop(self):
while not glfw.window_should_close(self.window):
self.check_for_shader_change()
frame_start_time = glfw.get_time()
if not self.freeze_time:
self.time = frame_start_time
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# Draw scene
self.shader.bind()
self.shader.set_uniforms({
'resolution':
self.resolution,
'time':
self.time,
'camera_position':
self.camera.position,
'camera_rotation':
self.camera.rotation.mat3()
})
glDrawArrays(GL_POINTS, 0, 1) # dummy vbo
self.shader.unbind()
# Draw UI
self.ui.draw({
'fps_label':
'{:4.0f}/{:2.0f} FPS, {:4.1f} ms ({:3.0f}%)'.format(
1 / self.frame_render_time, self.target_fps,
self.frame_render_time * 1000,
self.frame_render_time / self.target_frame_time * 100),
'time_label':
'Time: {:4.2f} s {}'.format(self.time,
'[f]' if self.freeze_time else ''),
'camera_label':
'Camera: [{:5.2f}, {:5.2f}, {:5.2f}] ({:3.0f}%), [{:5.1f}, {:4.1f}]'
.format(*self.camera.position, self.camera.speed * 100,
np.degrees(self.camera.yaw),
np.degrees(self.camera.pitch))
})
glfw.swap_buffers(self.window)
self.wait_for_frame_end(frame_start_time)
glfw.poll_events()
glfw.terminate()
class App:
""" Game of life pygame app """
DEFAULT_WINDOW_WIDTH = 600
DEFAULT_WINDOW_HEIGHT = 600
DEFAULT_NUM_ROWS = 100
DEFAULT_NUM_COLS = 100
TITLE = "Game of Life"
def __init__(self,
size=None,
window_size=None,
initial_active_file=None,
mode="game_of_life"):
"""
args:
size: number of rows and columns in the matrix
initial_active_file: json file to load the state of the matrix from
mode: str, 'game_of_life' or 'high_life', game mode
"""
num_cols, num_rows = size or [
self.DEFAULT_NUM_ROWS, self.DEFAULT_NUM_COLS
]
window_width, window_heigth = window_size or [
self.DEFAULT_WINDOW_WIDTH,
self.DEFAULT_WINDOW_HEIGHT,
]
pygame.init()
self.clock = pygame.time.Clock()
# load and set the logo
pygame.display.set_caption(self.TITLE)
if initial_active_file:
with open(args.f, "r") as f:
save_obj = json.load(f)
self.game = GameOfLife.load(save_obj)
num_cols, num_rows = self.game.size
else:
print("Game mode is: ", mode)
if mode == "game_of_life":
self.game = GameOfLife(num_rows, num_cols)
elif mode == "high_life":
self.game = GameOfLifeHighLife(num_rows, num_cols)
else:
raise Exception("Unknown game mode: {}".format(mode))
self.ui = UI(window_width, window_heigth, num_cols, num_rows,
self.game)
def draw(self, draw_all=False):
if draw_all:
self.ui.draw(None)
else:
# self.ui.draw(None)
self.ui.draw(self.changed_cells, score=self.game.score)
def update(self):
""" Update the cell matrix
"""
if self.autoplay or self.step:
self.changed_cells += self.game.step()
def save_game(self):
""" Saves a json containing the game state in a json file called 'game_of_life_dd_mm_yy_hh_mm_ss.json'
"""
now = datetime.datetime.now()
save_fpath = "game_of_life_{day}_{month}_{year}_{hour}_{minute}_{second}.json".format(
day=now.day,
month=now.month,
year=now.year,
hour=now.hour,
minute=now.minute,
second=now.second,
)
try:
print("saving game as: ", save_fpath)
self.game.save(save_fpath)
print("saved correctly")
except Exception as e:
print("error saving game: {}".format(e))
def handle_input(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN:
if event.key == Q or event.key == ESC:
self.running = False
if event.key == SP:
self.step = True
if event.key == A:
self.autoplay = not self.autoplay
if event.key == S:
self.save_game()
if event.key == R:
self.game.restart()
self.ui.draw(None)
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_position = pygame.mouse.get_pos()
window_surf = self.ui.position_to_surf(mouse_position)
print('clicked on: {} -> {} '.format(mouse_position,
window_surf))
if window_surf == "game":
row, col = self.ui.position_to_cell(mouse_position)
self.game.toggle((row, col))
self.changed_cells.append((row, col))
elif window_surf == "score":
pass
def main_loop(self):
self.running = True
self.autoplay = False
self.step = False
self.draw(True)
while self.running:
self.changed_cells = []
self.handle_input()
self.update()
self.draw()
self.clock.tick(30)
self.step = False
pygame.quit()
sys.exit()
# textpos = [window_dims[0] // 2, window_dims[1] // 2]
ui = UI(pygame)
i = 0
# GAME EVENT LOOP
game = True
while game:
i += 1
if i >= 30:
i = 0
ui.add_money()
# EVENT LOOP
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == K_ESCAPE:
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1: # LEFT CLICK
ui.handle_event(pygame, event)
ui.hover_check(pygame.mouse.get_pos())
pygame.display.flip()
clock.tick(FPS)
# DRAW BACKGROUND
window.fill(background)
# DRAW UI
ui.draw(pygame, window)
# TODO: add preprocess ability
if multistate:
ss_data = data.get_ss(args.state_id)
else:
ss_data = data
if args.lowess:
ss_data = ss_data.apply_lowess()
plot_data = ss_data.to_plotdata(args.caretype, args.coloring, args.drop_yearly)
# autoscale
if args.limit is None:
min_limit = plot_data.df.drop('date', axis=1).min().min()
max_limit = plot_data.df.drop('date', axis=1).max().max()
else:
min_limit = 0
max_limit = args.limit
ui = UI(plot_data, min_limit, max_limit, args.coloring, args.ppf)
ui.draw(plot_data.n)
if args.render_flag:
if args.render_video:
ui.render_animation_to_file(args.output_file)
else:
ui.render_image_to_file(args.output_file)
else:
ui.show_animation()
if event.key == K_ESCAPE:
sys.exit()
if event.key == K_w:
textpos[1]-=10
if event.key == K_a:
textpos[0]-=10
if event.key == K_s:
textpos[1]+=10
if event.key == K_d:
textpos[0]+=10
for gen in gens:
gen.level_up()
if event.type == pygame.MOUSEBUTTONDOWN:
ui.handle_event(gens, pygame, event)
ui.hover_check(gens, pygame.mouse.get_pos())
pygame.display.flip()
clock.tick(FPS)
# DRAW BACKGROUND
window.fill(background)
# DRAW TEXT
window.blit(text_big, tuple(textpos))
# DRAW UI
ui.draw(pygame, window, gens)
# DRAW Coins
for coin in coins:
coin.update()
window.blit(coin.image,(coin.x,coin.y))
class GameWindow(pyglet.window.Window): # Main game window
def __init__(self):
# Load config from file
self.cfg = load_cfg("Screen")
# Template for multisampling
gl_template = pyglet.gl.Config(
sample_buffers=1,
samples=2,
alpha_size=8
)
try: # to enable multisampling
gl_config = screen.get_best_config(gl_template)
except pyglet.window.NoSuchConfigException:
gl_template = pyglet.gl.Config(alpha_size=8)
gl_config = screen.get_best_config(gl_template)
logger.debug("Creating OpenGL context")
gl_context = gl_config.create_context(None)
logger.debug("Subclassing pyglet window, setting parameters.")
super(GameWindow, self).__init__(
context=gl_context,
config=gl_config,
resizable=False,
vsync=self.cfg["vsync"],
fullscreen=self.cfg["fullscreen"]
)
if not self.fullscreen:
logger.debug(
"Not fullscreen, setting screen resolution to {0}x{1}.".format(
self.cfg["width"], self.cfg["height"]
)
)
logger.debug("Centering window on screen.")
self.set_location(
(screen.width - self.cfg["width"]) // 2,
(screen.height - self.cfg["height"]) // 2
)
self.width, self.height = self.cfg["width"], self.cfg["height"]
# pyglet.gl.glClearDepth(1.0)
# pyglet.gl.glViewport(0, 0, self.width, self.height)
# pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION)
# pyglet.gl.glLoadIdentity()
# pyglet.gl.glOrtho(0, self.width, 0, self.height, 0.0, 1000)
# pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW)
self.debug = False
self.logger = logger
self.fps_display = pyglet.clock.ClockDisplay()
self.mouse_pos = (0, 0)
self.selected_object = None
logger.debug("Loading textures from folder \"{0}\".".format(RES_PATH))
self.load_textures()
self.load_animations()
self.fg_group = pyglet.graphics.OrderedGroup(2)
self.mid_group = pyglet.graphics.OrderedGroup(1)
self.bg_group = pyglet.graphics.OrderedGroup(0)
self.batches = OrderedDict()
self.batches["gui0"] = pyglet.graphics.Batch()
self.batches["gui1"] = pyglet.graphics.Batch()
self.batches["gui2"] = pyglet.graphics.Batch()
self.batches["gui3"] = pyglet.graphics.Batch()
self.flush()
self.offset_x, self.offset_y = 0, 0
# GUI
self.build_ui()
self.load_map_files()
self.game = Game(self)
self.game.newgame(self.selected_mapfile)
self.update_offset()
def flush(self):
self.batches["dungeon"] = pyglet.graphics.Batch()
self.batches["dungeon_overlay"] = pyglet.graphics.Batch()
self.batches["creatures"] = pyglet.graphics.Batch()
self.batches["player"] = pyglet.graphics.Batch()
self.batches["projectiles"] = pyglet.graphics.Batch()
def load_textures(self):
logger.info("Loading textures...")
goblin_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'crappy_goblin.png'))
)
player_body_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'player_body.png'))
)
player_body_glow_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'player_body_glow.png'))
)
player_hand_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'player_hands.png'))
)
player_hand_glow_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'player_hands_glow.png'))
)
button_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'button.png'))
)
button_down_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'button_down.png'))
)
fireball_s_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'fireball_s.png'))
)
fireball_l_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'fireball_l.png'))
)
bolt_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'white_bolt.png'))
)
rc_img = center_image(
pyglet.image.load(os.path.join(RES_PATH, 'red_circle.png'))
)
cursor_default_img = pyglet.image.load(
os.path.join(RES_PATH, "cursors", "default.png")
)
cursor_projectile_img = pyglet.image.load(
os.path.join(RES_PATH, "cursors", "projectile.png")
)
self.textures = dict(
goblin=goblin_img,
player_body=player_body_img,
player_body_glow=player_body_glow_img,
player_hand=player_hand_img,
player_hand_glow=player_hand_glow_img,
button=button_img,
button_down=button_down_img,
fireball1=fireball_s_img,
fireball2=fireball_l_img,
bolt=bolt_img,
redcircle=rc_img,
)
self.reticules = dict(
default=pyglet.window.ImageMouseCursor(cursor_default_img, 2, 32),
projectile=pyglet.window.ImageMouseCursor(
cursor_projectile_img, 20, 20
),
)
logger.info(
"Done, {} textures loaded.".format(len(self.textures))
)
def load_single_texture(self, name, center=False):
if center:
return center_image(
pyglet.image.load(os.path.join(RES_PATH, name + '.png'))
)
else:
return pyglet.image.load(os.path.join(RES_PATH, name + '.png'))
def get_texture(self, name):
try:
return self.textures[name]
except KeyError:
logger.debug("Texture \"{0}\" not found".format(name))
return None
# def on_resize(self, width, height):
# # Based on the default with more useful clipping planes
# pyglet.gl.glViewport(0, 0, width, height)
# pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION)
# pyglet.gl.glLoadIdentity()
# pyglet.gl.glOrtho(0, width, 0, height, 0.0, 1000)
# pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW)
def load_animations(self):
logger.info("Loading animations...")
self.animator = Animator(self)
logger.info(
"Finished loading {} animations.".format(
len(self.animator.animations)
)
)
# for key, value in self.animator.animations.items():
# print(key)
logger.info("Loading player animations...")
img = self.load_single_texture("player_sheet")
player_anim_grid = pyglet.image.ImageGrid(img, 8, 6)
for seq in player_anim_grid:
seq = center_image(seq)
down_anim_seq = reversed(player_anim_grid[42:48])
down_static = player_anim_grid[(7, 4)]
left_anim_seq = reversed(player_anim_grid[36:42])
left_static = player_anim_grid[(6, 4)]
right_anim_seq = reversed(player_anim_grid[30:36])
right_static = player_anim_grid[(5, 4)]
up_anim_seq = reversed(player_anim_grid[24:30])
up_static = player_anim_grid[(4, 4)]
ld_anim_seq = reversed(player_anim_grid[18:24])
ld_static = player_anim_grid[(3, 4)]
rd_anim_seq = reversed(player_anim_grid[12:18])
rd_static = player_anim_grid[(2, 4)]
lu_anim_seq = reversed(player_anim_grid[6:12])
lu_static = player_anim_grid[(1, 4)]
ru_anim_seq = reversed(player_anim_grid[0:6])
ru_static = player_anim_grid[(0, 4)]
down_anim = pyglet.image.Animation.from_image_sequence(
down_anim_seq, 0.2, True
)
left_anim = pyglet.image.Animation.from_image_sequence(
left_anim_seq, 0.2, True
)
right_anim = pyglet.image.Animation.from_image_sequence(
right_anim_seq, 0.2, True
)
up_anim = pyglet.image.Animation.from_image_sequence(
up_anim_seq, 0.2, True
)
ld_anim = pyglet.image.Animation.from_image_sequence(
ld_anim_seq, 0.2, True
)
rd_anim = pyglet.image.Animation.from_image_sequence(
rd_anim_seq, 0.2, True
)
lu_anim = pyglet.image.Animation.from_image_sequence(
lu_anim_seq, 0.2, True
)
ru_anim = pyglet.image.Animation.from_image_sequence(
ru_anim_seq, 0.2, True
)
self.player_anim_grid = dict(
down=down_anim,
left=left_anim,
right=right_anim,
up=up_anim,
leftdown=ld_anim,
rightdown=rd_anim,
leftup=lu_anim,
rightup=ru_anim
)
self.player_static_img = dict(
down=down_static,
left=left_static,
right=right_static,
up=up_static,
leftdown=ld_static,
rightdown=rd_static,
leftup=lu_static,
rightup=ru_static
)
logger.info("Finished loading player animations.")
def get_anim(self, name):
try:
return self.animator.get_anim(name)
except KeyError:
logger.error("No animation by name {} found".format(name))
def load_map_files(self):
self.maplist = sorted(glob.glob(os.path.join(RES_PATH, '*.tmx')))
try:
self.selected_mapfile = self.maplist[0]
except IndexError:
logger.error("No map files found!")
self.selected_mapfile = None
def set_reticule(self, reticule):
if reticule == "projectile":
self.set_mouse_cursor(self.reticules["projectile"])
else:
self.set_mouse_cursor(self.reticules["default"])
def build_ui(self):
self.ui = UI(self)
self.ui.add_button(
self.width - 32, self.height - 16, text="Exit",
cb=pyglet.app.exit
)
self.ui.add_bar(
self.width - 100, 50,
text="Health", width=200, height=20,
color="red", shows="hp"
)
self.ui.add_bar(
self.width - 100, 30,
text="Stamina", width=200, height=20,
color="green", shows="sta"
)
self.ui.add_bar(
self.width - 100, 10,
text="Mana", width=200, height=20,
color="blue", shows="mp"
)
pyglet.clock.schedule_interval(self.ui.update, 1.0 / FPS)
def update_offset(self, dx=False, dy=False):
self.offset_x += dx
self.offset_y += dy
self.update_display_dungeon()
def set_offset(self, x, y):
self.offset_x, self.offset_y = x, y
self.update_display_dungeon()
def get_windowpos(self, x, y, check=False, tol=0, precise=False):
if check:
if (
(x + self.offset_x > self.width + tol) or
(x + self.offset_x < 0 - tol)
):
return False
if (
(y + self.offset_y > self.height + tol) or
(y + self.offset_y < 0 - tol)
):
return False
if precise:
return x + self.offset_x, y + self.offset_y
else:
return int(x + self.offset_x), int(y + self.offset_y)
def grid_to_window(self, x, y):
return x * 32, y * 32
def get_gamepos(self, x, y, check=False, tol=0):
if check:
if (
(x - self.offset_x > self.width + tol) or
(x - self.offset_x < 0 - tol)
):
return False
if (
(y - self.offset_y > self.height + tol) or
(y - self.offset_y < 0 - tol)
):
return False
return int(x - self.offset_x), int(y - self.offset_y)
def on_mouse_press(self, x, y, button, modifiers):
p = self.game.player
gamepos = self.get_gamepos(x, y)
if button == 1:
if self.ui.check(x, y): # Checks if mouse press is on ui elements
logger.debug("Button hit, not registering presses on grid.")
elif p: # if its not, handle presses as usual
if p.actions["targeting"]:
if (
p.actions["targeting"].use(
target=self.get_gamepos(x, y)
)
):
p.clear_ability_target()
elif len(self.game.enemies) > 0:
for e in self.game.spatial_hash.get_objects_from_point(
gamepos, radius=32, type=Enemy
):
if get_dist(e.x, e.y, *gamepos) <= 24:
p.set_target(e)
break
else:
p.clear_target()
if button == 4:
if self.ui.check(x, y, dry=True):
pass
elif p:
p.clear_ability_target()
if len(self.game.enemies) > 0:
for e in self.game.spatial_hash.get_objects_from_point(
gamepos, radius=32, type=Enemy
):
if get_dist(e.x, e.y, *gamepos) <= 24:
p.auto_attack_target = e
p.set_target(e)
break
else:
p.clear_target()
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
pass
def on_mouse_release(self, x, y, button, modifiers):
if button == 1:
if self.ui.check(x, y, press=False):
pass
def on_mouse_motion(self, x, y, dx, dy):
self.mouse_pos = (x, y)
def on_key_press(self, symbol, modifiers):
k = pyglet.window.key
if symbol == k.ESCAPE:
logger.info("Exiting...")
pyglet.app.exit()
elif symbol == k.F12:
self.debug = not self.debug
elif symbol == k.F5:
self.game.newgame(self.selected_mapfile)
elif symbol == k.F2:
self.game.add_enemy(*self.get_gamepos(*self.mouse_pos))
if self.game.player:
if symbol == k.W:
self.game.player.move_dir["up"] = True
elif symbol == k.A:
self.game.player.move_dir["left"] = True
elif symbol == k.S:
self.game.player.move_dir["down"] = True
elif symbol == k.D:
self.game.player.move_dir["right"] = True
if symbol == k.F1:
for i in range(50):
self.game.player.levelup(attribute="str")
self.game.player.levelup(attribute="agi")
self.game.player.levelup(attribute="int")
if symbol == k.F3:
self.game.player.die()
if symbol == k.LSHIFT:
self.game.player.actions["sprint"] = True
# Cast abilitites
target = self.get_gamepos(*self.mouse_pos)
if symbol == k._1:
self.game.player.use_ability(1, target=target)
if symbol == k._2:
self.game.player.use_ability(2, target=target)
if symbol == k._3:
self.game.player.use_ability(3, target=target)
if symbol == k._4:
self.game.player.use_ability(4, target=target)
# Level up attributes
if symbol == k.EXCLAMATION:
self.game.player.levelup(attribute="str")
if symbol == k.DOUBLEQUOTE:
self.game.player.levelup(attribute="agi")
if symbol == k.HASH:
self.game.player.levelup(attribute="int")
else:
if symbol == k.F3:
self.game.spawn_player(
self.grid_to_window(*self.game.dungeon.startroom.center)
)
def on_key_release(self, symbol, modifiers):
k = pyglet.window.key
if self.game.player:
if symbol == k.W:
self.game.player.move_dir["up"] = False
elif symbol == k.A:
self.game.player.move_dir["left"] = False
elif symbol == k.S:
self.game.player.move_dir["down"] = False
elif symbol == k.D:
self.game.player.move_dir["right"] = False
if symbol == k.LSHIFT:
self.game.player.actions["sprint"] = False
def update_display_dungeon(self):
x, y = int(self.offset_x), int(self.offset_y)
self.game.dungeon_sprite.x = x
self.game.dungeon_sprite.y = y
self.game.dungeon_overlay_sprite.x = x
self.game.dungeon_overlay_sprite.y = y
def update(self, dt):
if self.game:
self.game.update(dt)
def render(self, dt):
pyglet.gl.glClearColor(*lookup_color("dgrey", gl=True))
self.clear()
pyglet.gl.glEnable(pyglet.gl.GL_DEPTH_TEST)
self.batches["dungeon"].draw()
self.batches["gui0"].draw()
self.batches["creatures"].draw()
self.batches["player"].draw()
self.batches["projectiles"].draw()
if hasattr(self, "animator"):
self.animator.render()
self.batches["dungeon_overlay"].draw()
# enemy_count = pyglet.text.Label(
# text=str(len(self.game.enemies)), font_name=None, font_size=18,
# x=50, y=400, anchor_x="left", anchor_y="top",
# color=lookup_color("black")
# )
# enemy_count.draw()
self.ui.draw()
class App():
def __init__(self):
super().__init__()
pygame.init()
self.EVENTS = {
pygame.QUIT: self.on_quit,
pygame.VIDEORESIZE: self.on_resize,
pygame.MOUSEBUTTONDOWN: self.mouse_event("down"),
pygame.MOUSEBUTTONUP: self.mouse_event("up"),
pygame.MOUSEMOTION: self.mouse_event("move"),
pygame.KEYDOWN: self.on_key
}
self.mousedown = {b: False for b in ("l", "r", "m")}
self.mousedrag = {b: False for b in ("l", "r", "m")}
pygame.display.set_caption("Solitaire")
pygame.display.set_icon(assets.get_icon())
self.screen = pygame.display.set_mode(
(constants.WIDTH, constants.HEIGHT),
constants.SCREEN_FLAGS,
vsync=True)
self.clock = pygame.time.Clock()
assets.load_svgs()
self.game = None
self.ui = UI(self)
self.on_resize(
pygame.event.Event(pygame.VIDEORESIZE,
size=(constants.WIDTH, constants.HEIGHT)))
self.running = True
def mouse_event(self, name):
def inner(event):
btns = []
button, buttons = getattr(event, "button",
-1), getattr(event, "buttons", [])
if button == pygame.BUTTON_LEFT or pygame.BUTTON_LEFT in buttons:
btns.append("l")
if button == pygame.BUTTON_RIGHT or pygame.BUTTON_RIGHT in buttons:
btns.append("r")
if button == pygame.BUTTON_MIDDLE or pygame.BUTTON_MIDDLE in buttons:
btns.append("m")
pos = self.screen_to_game(event.pos)
getattr(self.ui, f"on_mouse{name}", lambda e: None)(event)
for b in btns:
getattr(self, f"on_mouse{name}", lambda e, b: None)(event, b)
getattr(self, f"on_mouse{name}_{b}", lambda e: None)(event)
getattr(self.ui, f"on_mouse{name}_{b}", lambda e: None)(event)
if self.game:
getattr(self.game, f"on_mouse{name}_{b}",
lambda p: None)(pos)
return inner
def on_key(self, event):
print(pygame.key.name(event.key))
getattr(self, f"on_key_{pygame.key.name(event.key)}".lower(),
lambda e: None)(event)
def loop(self):
while self.running:
self.clock.tick(200)
print(f"FPS: {self.clock.get_fps():3.0f}", end="\r")
self.events()
self.ui.draw(self.screen)
def events(self):
for event in pygame.event.get():
try:
self.EVENTS[event.type](event)
except KeyError as e:
print(
f"Event {pygame.event.event_name(event.type)} not handled",
event.__dict__)
def on_quit(self, event):
self.running = False
def on_resize(self, event):
width, height = event.size
if width / height < constants.RATIO:
self.scale = width / constants.WIDTH
else:
self.scale = height / constants.HEIGHT
self.origin = ((width / self.scale - constants.WIDTH) * .5,
constants.APPBAR_HEIGHT)
assets.render_svgs(self.scale)
self.ui.render(event.size, self.scale)
def game_win(self):
self.game.paused = True
self.ui.current = UIType.WIN
# region Mouse events
def on_mousedown(self, event, b):
self.mousedown[b] = True
def on_mousemove(self, event, b):
if not self.mousedrag[b] and self.mousedown[b]:
self.mousedrag[b] = True
self.mouse_event("dragbegin")(event)
self.mousedrag[b] = self.mousedown[b]
if self.mousedrag[b]:
self.mouse_event("drag")(event)
def on_mouseup(self, event, b):
self.mousedown[b] = False
if self.mousedrag[b]:
self.mouse_event("dragend")(event)
else:
self.mouse_event("click")(event)
def on_mousedragend(self, event, b):
self.mousedrag[b] = False
# endregion
# region Keyboard events
def on_key_n(self, event):
if event.mod & pygame.KMOD_CTRL:
self.new_game()
def on_key_d(self, event):
if self.ui.current == UIType.GAME:
self.game.deal_card()
def on_key_c(self, event):
if self.ui.current == UIType.GAME:
self.game.collect_all()
def on_key_z(self, event):
if self.ui.current == UIType.GAME and event.mod & pygame.KMOD_CTRL:
self.game.undo()
def on_key_y(self, event):
if self.ui.current == UIType.GAME and event.mod & pygame.KMOD_CTRL:
self.game.redo()
def on_key_s(self, event):
if self.ui.current == UIType.GAME:
self.game.cancel_animations()
def on_key_escape(self, event):
if self.ui.current == UIType.GAME:
self.game.pause()
def on_key_space(self, event):
if self.ui.current == UIType.GAME:
self.game.cancel_animations()
def on_key_f12(self, event):
self.game_win()
# endregion
def screen_to_game(self, coords):
return (coords[0] / self.scale - self.origin[0],
coords[1] / self.scale - self.origin[1])
def game_to_screen(self, coords):
return ((coords[0] + self.origin[0]) * self.scale,
(coords[1] + self.origin[1]) * self.scale)
def new_game(self):
self.game = Game(self)
self.ui.current = UIType.GAME
ui = UI(player, MAIN_WINDOW)
ui.init_ui()
# Create Guardian
guard = Guardian(const.SPR_GUARD, level, level.end_position)
# Items Creation
create_item(Type.TUBE)
create_item(Type.ETHER)
create_item(Type.NEEDLE)
print('Nb items in Level : ' + str(len(Item.instances_in_level)))
print('...Ready')
# Init Booleans
end_pause = False
game_loop = True
while game_loop: # Game Loop
level.draw(MAIN_WINDOW) # Draw Level
ui.draw() # Draw UI
MAIN_WINDOW.blit(guard.sprite, (guard.x, guard.y)) # Draw Guardian
for item in Item.instances_in_level:
MAIN_WINDOW.blit(item.sprite, (item.position)) # Draw Items
for event in pygame.event.get():
# Events management
if (event.type == QUIT or
event.type == KEYDOWN and event.key == K_ESCAPE):
# Exit Game event
game_loop = False
game_window = False
if event.type == KEYDOWN:
# Inputs
