def admin_menu():
from pygame.display import set_mode, list_modes, set_caption
from pygame import init, quit
init()
screen = set_mode(list_modes()[0])
set_caption("Hero Misadventures")
menu = Menu(("Debug", "Release"), screen, text_color=color("White"), surface=color("Black"),
selection_color=color("Slate Gray"))
while True:
choose = menu.update()
if choose == -1:
continue
else:
if choose == 0:
from cProfile import runctx
from pstats import Stats
runctx("from bin.Interaction import debug_menu; debug_menu(screen)", {"screen": screen}, {}, "test/profiling.prof")
file = open("test/profiling.txt", "w")
info = Stats("test/profiling.prof", stream=file)
info.strip_dirs().sort_stats("cumulative").print_stats()
elif choose == 1:
quit()
start_menu()
return
def flow_projects_select(self,btn):
#make the selected project the active one
try:
idu = btn.Id if isinstance(btn, ArtifactController)\
else btn._id #IGNORE:W0212
self.current_project = self.artifacts[idu]
self.viewCurrentProject(btn)
except KeyError:
#create new project
lbl = self.new_project_pressed()
if lbl is None: return
self.current_project = self.artifacts[lbl.Id]
set_caption(self.current_project[0].Name)
#we need to populate the releases flow with any release
#in the current project
self.load_releases()
self.container_reset_children('release_flow')
self.container_reset_children('sprint_flow')
self.container_reset_children('story_flow')
self.container_reset_children('task_flow')
if self.current_project and self.current_project[0].Children:
for release in self.current_project[0].Children:
if release in self.artifacts:
r = self.artifacts[release][0]
if r.ArtifactType != 'Release': continue
self.newRelease(r)
else:
Log.debug('Project: %s found a release: %s not in releases' % \
(self.current_project[0].Name,release))
def my_slideshow(new_img, img, screen, file, num_imgs, rect):
if not gl.TOGGLE_FULLSCREEN_SET:
screen = set_mode(screen.get_size())
set_caption("Slideshow Options - imgv")
speed = get_speed(screen, new_img, rect, gl.files[file], file, num_imgs)
if not speed == -1: # didn't hit Esc from get_speed:
gl.SLIDE_SHOW_RUNNING = 1
disable_screensaver()
dont_call = 0
pygame.event.set_blocked(MOUSEMOTION)
while 1:
event = pygame.event.poll()
pygame.time.wait(1)
check_quit(event)
if event.type == KEYDOWN and event.key not in (K_LALT, K_RALT, K_LCTRL, K_RCTRL, K_p, K_PAUSE, K_TAB, K_SPACE, K_BACKSPACE):
stopped_msg(screen)
my_update_screen(new_img, screen, rect, file, len(gl.files))
file = file - 1
break
if hit_key(event, K_p) or hit_key(event, K_PAUSE):
pause(screen)
my_update_screen(new_img, screen, rect, file, len(gl.files))
if dont_call == 1:
break
if not gl.WRAP_SLIDESHOW:
if file < num_imgs:
(new_img, file, rect, dont_call) = show_slideshow_img(screen, new_img, file, num_imgs, speed)
if gl.WRAP_SLIDESHOW:
if file >= num_imgs:
file = 0
(new_img, file, rect, dont_call) = show_slideshow_img(screen, new_img, file, num_imgs, speed)
pygame.time.delay(5) # don't hog CPU
if not gl.TOGGLE_FULLSCREEN_SET:
screen = set_mode(screen.get_size(), RESIZABLE)
return (new_img, new_img, new_img, file, rect)
def __init__(self):
init()
self.n = 3
self.planets = {i:PLANET() for i in range(self.n)}
self.cm_velocity_zero()
display.set_caption('Planets')
self.clock = time.Clock()
def show_fps():
'''
Displays the game's framerate on the window caption. Meant to be called
in Debug mode with assert statements so that this is effortlessly stripped
out in Release mode.
@invariant: MUST return an object that evaluates to False.
'''
set_caption("FPS: %3g" % round(fps_timer.get_fps(), 3))
def run(self):
pygame.init()
clock = pygame.time.Clock()
self.mainDisplay = display.set_mode((int(self.W), int(self.H)))
display.set_caption(self.title)
self.running = True
while self.running:
self.mainDisplay.fill(self.bg)
mouse = pygame.mouse.get_pos()
events = pygame.event.get() #calling this seems to empty the event list
for event in events:
if event.type == pygame.QUIT:
self.running = False
break
elif event.type == pygame.MOUSEMOTION:
self.hoverCheck(mouse)
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
self.clickCheck()
#end
#end
#end
self.drawButtons()
for m in self.modules:
m.dispatch(events, mouse)
display.update()
clock.tick(self.fps)
#end
pygame.quit()
quit()
def init() -> None:
pygame.init()
global g_surface
g_surface = pgdisplay.set_mode((670, 600))
pgdisplay.set_caption("Violin Note Practice")
pgdisplay.set_icon(pgimage.load("./data/Images/treble_clef.png"))
def run(self):
icon = image.load("Icon.png")
display.set_icon(icon)
self.__window = display.set_mode(SIZE)
display.set_caption("Twenty Nine")
self.__window.fill(COLOURS.get('BOARD'))
display.flip()
while True:
r, w, x = select(self.__read, self.__write, self.__error, 0)
for f in r:
if f is self.__listener:
data = receive(f)
if data:
print data
if data[0] == "ID":
self.__ID = int(data[1])
if data[0] == "Cards":
print data[1]
event = pyevent.poll()
if event.type == QUIT:
self.__Quit()
break
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.__Quit()
break
else:
send(self.__listener, chr(event.key))
elif event.type == MOUSEBUTTONDOWN:
print event
def __init__(self, timer):
init()
self.screen = display.set_mode((GAME_WIDTH, GAME_HEIGHT))
display.set_caption("Whack a MOLE")
self.img_bg = image.load("assets/background.png")
self.img_hole = image.load("assets/hole.png")
self.img_hammer = image.load("assets/mallet.png")
self.img_bang = image.load("assets/bang.png")
self.img_oops = image.load("assets/oops.png")
self.img_click = image.load("assets/click.png")
self.img_space = image.load("assets/space.png")
self.img_night = image.load("assets/night.png")
self.img_sunset = image.load("assets/sunset.png")
self.img_night = transform.scale(self.img_night,
(GAME_WIDTH, GAME_HEIGHT))
self.img_sunset = transform.scale(self.img_sunset,
(GAME_WIDTH, GAME_HEIGHT))
self.img_space = transform.scale(self.img_space,
(GAME_WIDTH, GAME_HEIGHT))
self.img_click = transform.scale(self.img_click,
(GAME_WIDTH, GAME_HEIGHT))
self.img_hole = transform.scale(self.img_hole, (200, 45))
self.img_hammer = transform.scale(self.img_hammer, (200, 200))
self.img_bang = transform.scale(self.img_bang, (150, 150))
self.img_oops = transform.scale(self.img_oops, (150, 150))
self.img_hammer_hit = transform.rotate(self.img_hammer.copy(), 35)
self.img_hammer_norm = transform.rotate(self.img_hammer.copy(), 10)
self.timer = timer
self.fixed_timer = timer
self.reset()
self.run()
def __init__(self, size: list, fps=60, show_fps=False) -> None:
pygame.init()
pygame.font.init()
if os.name == "nt":
self.myfont = pygame.font.SysFont(pygame.font.get_fonts()[8], 16)
size = round(size[0] * 9), size[1] * 19
else:
self.myfont = pygame.font.SysFont('notomono', 16)
size = round(size[0] * 10), size[1] * 19
self.FPS = fps
self.size = size
self.show_fps = show_fps
self.event_list = []
self.screen = pygame.display.set_mode(size)
set_caption("Console")
self.clock = pygame.time.Clock()
def __init__(self, *, timer: int = None, autostart: bool = True):
# Init pygame
init()
# Create pygame screen
self.screen = display.set_mode(
(Constants.GAMEWIDTH, Constants.GAMEHEIGHT))
display.set_caption(Constants.TEXTTITLE)
# Load background
self.img_background = image.load(Constants.IMAGEBACKGROUND)
self.img_background = transform.scale(
self.img_background, (Constants.GAMEWIDTH, Constants.GAMEHEIGHT))
# Load hole
self.img_hole = image.load(Constants.IMAGEHOLE)
self.img_hole = transform.scale(
self.img_hole, (Constants.HOLEWIDTH, Constants.HOLEHEIGHT))
# Load mallet
self.img_mallet = image.load(Constants.IMAGEMALLET)
self.img_mallet = transform.scale(
self.img_mallet, (Constants.MALLETWIDTH, Constants.MALLETHEIGHT))
# Set timer
self.timer = timer
# Reset/initialise data
self.reset()
# Run
if autostart:
self.run()
def start_menu():
from pygame.display import set_mode, list_modes, set_caption
from pygame import init, quit
from pygame.constants import FULLSCREEN
from bin.Controller import process
from obj.Field import Field
init()
screen = set_mode(list_modes()[0], FULLSCREEN)
set_caption("Hero Misadventures")
menu = Menu(("Previous Field", "New Field", "Load Field", "Quit"),
screen,
surface=color("Lawn Green"),
selection_color=color("Lime Green"),
text_color=color("Medium Blue"))
while True:
choose = menu.update()
if choose == 0:
field = Field(screen)
process(screen, field)
elif choose == 1:
from ctypes import cdll
cdll.LoadLibrary("Generator.so").main_generator(
"res/GENERATOR.HMinf", "res/FIELD.HMmap")
field = Field(screen)
process(screen, field)
elif choose == 2:
from pickle import load
field = load(open("res/SAVE.HMsave", "rb"))
field.screen = screen
process(screen, field)
elif choose == 3:
quit()
return
def admin_menu():
from pygame.display import set_mode, list_modes, set_caption
from pygame import init, quit
init()
screen = set_mode(list_modes()[0])
set_caption("Hero Misadventures")
menu = Menu(("Debug", "Release"),
screen,
text_color=color("White"),
surface=color("Black"),
selection_color=color("Slate Gray"))
while True:
choose = menu.update()
if choose == -1:
continue
else:
if choose == 0:
from cProfile import runctx
from pstats import Stats
runctx(
"from bin.Interaction import debug_menu; debug_menu(screen)",
{"screen": screen}, {}, "test/profiling.prof")
file = open("test/profiling.txt", "w")
info = Stats("test/profiling.prof", stream=file)
info.strip_dirs().sort_stats("cumulative").print_stats()
elif choose == 1:
quit()
start_menu()
return
def pygame_loop(surface_: surface.Surface,
clock: time.Clock,
update: bool = True) -> None:
global num_of_iterations
clock.tick(FPS)
if update:
num_of_iterations += 1
display.set_caption(
f"Diffusion Limited Aggregation - {BETA} - {num_of_iterations}")
for event in events.get():
if event.type == pygame.QUIT:
at_end()
keys = pygame.key.get_pressed()
if keys[pygame.K_ESCAPE]:
at_end()
if update:
p.update()
surface_.fill(BLACK)
render(surface_)
display.flip()
def __initialize_window(self):
self.running = False
init()
display.set_icon(image.load(read_preferences().get_logo_image()))
display.set_caption(read_preferences().get_title())
def main():
# On initialise PyGame
pygame.init()
display.set_caption("Pong")
# Crée une surface sur l'écran
screen = display.set_mode((800, 600))
# On instancie notre objet qui va gérer les règles du jeu
game = Game()
# On lance l'initialisation du jeu
game.init(screen)
# Tant qu'on indique pas le contraire, on reste dans la boucle de jeu
# Chaque tour de boucle représente une frame
while game.should_run:
# On efface l'ecran (on le rempli de noir, c'est pareil)
screen.fill((0, 0, 0))
# On lance la fonction update du jeu
game.update()
# On met à jour l'affichage de l'écran pour afficher les modifs
display.update()
# On récupère tous les évènement de pygame
for event in pygame.event.get():
# On s'occupe uniquement de l'évènement QUIT (croix, alt+f4)
if event.type == pygame.QUIT:
# On met la variable running à False ce qui annule la boucle
game.should_run = False
def main():
pygame.init()
display.set_mode((1280, 720), pygame.RESIZABLE)
display.set_caption("Ethos")
display.set_gamma_ramp
game = EthosMain()
game.run()
def command_thumbs(screen, new_img, file):
normal_cursor()
gl.THUMBING = 1
screen_width = screen.get_width()
if gl.THUMB_VAL.upper() == "AUTO" or gl.USING_THUMB_DEFAULT:
gl.USING_THUMB_DEFAULT = 1
if screen_width == 640:
gl.THUMB_VAL = "85x90"
elif screen_width == 800:
gl.THUMB_VAL = "108x114"
elif screen_width == 1024:
gl.THUMB_VAL = "108x104"
else:
gl.THUMB_VAL = "100x100"
if not gl.TOGGLE_FULLSCREEN_SET:
screen = set_mode(screen.get_size()) # take away resize priviledges
paint_screen(gl.IMGV_COLOR)
set_caption("imgv")
(new_img, new_img, new_img, file) = thumbs_engine(screen, new_img, file)
if not gl.TOGGLE_FULLSCREEN_SET:
screen = set_mode(screen.get_size(), RESIZABLE) # restore resize priviledges
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
normal_cursor()
gl.THUMBING = 0
return (new_img, new_img, new_img, file, rect)
def run_game():
init()
uni_settings = settings()
screen = display.set_mode(uni_settings.screen_size)
display.set_caption('Universe')
while True:
screen.fill(uni_settings.black)
gf.check_events()
# gf.orbit(screen)
# G.solar_system(screen, uni_settings, uni_settings.earth_angle, uni_settings.moon_angle, uni_settings.
# mercury_angle, uni_settings.venus_angle,uni_settings.mars_angle, uni_settings.jupiter_angle,
# uni_settings.saturn_angle, uni_settings.uranus_angle, uni_settings.neptune_angle)
# G.rotating_solar_system(uni_settings)
for i in range(1, num_stellar + 1):
stellar_data = G.read_data('data.txt', i)
stellar = Planet(screen, stellar_data[1], stellar_data[2],
stellar_data[3], stellar_data[5])
temp = stellar.generate_planet('clockwise', [0, 0])
G.rotating_random_system('data.txt', i, stellar_data[4],
stellar_data[5])
for i in range(1, num_planet + 1):
print(i)
planet_data = G.read_planet_data('planet_data.txt', i)
planet = Planet(screen, planet_data[1], [temp[0], temp[1]],
planet_data[3], planet_data[5])
planet.generate_planet('clockwise', [120, 120])
G.rotating_random_planet('planet_data.txt', i, planet_data[4],
planet_data[5])
display.flip()
def hover_fx(screen, curdir, x, cursor):
slash = os.sep
dash = ' - '
flag = 0
for it in x:
if it[0].collidepoint(cursor):
flag = 1
(shortcut, dirname) = it[1].split(gl.DIRNUMSEP)
if dirname == slash:
fullpath = curdir.split(slash)[0] + slash
elif dirname == '..':
fullpath = slash.join(curdir.rstrip(slash).split(slash)[:-1]) + slash
if fullpath.split(dash)[0] == slash:
# make it so when in root dir of MS-Windows it prints drive letter
fullpath = curdir.split(slash)[0] + slash
else:
fullpath = curdir + dirname + slash
gl.OLD_CAP = fullpath + ' [' + shortcut + '] - imgv'
if gl.OLD_CAP != get_caption()[0]:
# perform only once (otherwise it flashes in title bar)
set_caption(gl.OLD_CAP)
break
if not flag:
gl.OLD_CAP = curdir + " - imgv"
# nothing was hovered on the last pass
if gl.OLD_CAP != get_caption()[0]:
set_caption(gl.OLD_CAP)
def __init__(self,
width: int,
height: int,
title="Polaron App",
resizable=True,
fullscreen=False):
"""Create a new Display."""
self.threaded = is_threaded()
init()
if not self.threaded:
set_caption(title)
else:
self._last_frame = None
self.title = title
self.resizable = resizable
self.fullscreen = fullscreen
self._flags = RESIZABLE if resizable else 0 | FULLSCREEN if fullscreen else 0
self.root = RootNode(**{
"x": 0,
"y": 0,
"width": width,
"height": height
})
self._generate(width, height)
self.root.attach_receiver(QuitReceiver())
self.root.attach_receiver(
EventReceiver(VIDEORESIZE, self._handle_resize))
def __init_window(self):
init()
self.__surface = display.set_mode(self.__screen_size)
display.set_caption(
'Game of Life --- SPACE - Toggle evolution, R - reset generation')
model = Population(PygameCellFactory(), self.__screen_size)
self.__board_view = PygameBoard('Population', model, self.__surface)
model.add_observer(self.__board_view)
self.controller.model = model
self.controller.view = self.__board_view
while True:
for e in event.get():
if e.type == QUIT:
quit()
exit()
if e.type == KEYDOWN:
if e.key == K_SPACE:
model.toggle_evolution()
if e.key == K_r:
model.reset_population()
self.controller.handle()
self.__pyg_clock.tick(40)
display.flip()
def __init__(self, x_dim, y_dim):
init()
# Dimensions Game Screen (grid)
self.x_dim = x_dim
self.y_dim = y_dim
self.MARGIN = 8
self.HEADER_BAR = 70
self.SPACE_PIXELS = 32
if (self.SPACE_PIXELS*self.x_dim + 2 * self.MARGIN) < 550 :
self.WIDTH = 550
else:
self.WIDTH = self.SPACE_PIXELS*self.x_dim + 2 * self.MARGIN
self.HEIGHT = self.SPACE_PIXELS*self.y_dim + 2 * self.MARGIN + self.HEADER_BAR
self._screen = display.set_mode((self.WIDTH, self.HEIGHT))
display.set_caption("BitSweeper")
if (self.x_dim*self.SPACE_PIXELS) < self.WIDTH :
self.GAME_SCREEN_LEFT = (self.WIDTH / 2) - ((self.x_dim* self.SPACE_PIXELS) / 2)
else :
self.GAME_SCREEN_LEFT = self.MARGIN
# Dimensions buttons
self.BUTTON_WIDTH = math.floor(self.WIDTH/3)
# Dimensions timer and flag counter
self.TIMER_WIDTH = 150
self.FLAG_COUNTER_HEIGHT = 20
self.FLAG_COUNTER_WIDTH = 150
# Game Screen (grid)
self._gameScreen = self._screen.subsurface(
Rect(self.GAME_SCREEN_LEFT, self.HEADER_BAR + self.MARGIN, self.SPACE_PIXELS*self.x_dim, self.SPACE_PIXELS*self.y_dim)
)
# Reset button
self._reset = self._screen.subsurface(
Rect(self.MARGIN, self.MARGIN, self.BUTTON_WIDTH, self.HEADER_BAR-self.MARGIN)
)
# Timer and flag counter
self._timer = self._screen.subsurface(
Rect(self.MARGIN + self.BUTTON_WIDTH + self.MARGIN, self.MARGIN, self.TIMER_WIDTH, self.FLAG_COUNTER_HEIGHT)
)
self._flagCounter = self._screen.subsurface(
Rect(self.MARGIN + self.BUTTON_WIDTH + self.MARGIN, self.MARGIN + self.FLAG_COUNTER_HEIGHT, self.FLAG_COUNTER_WIDTH, self.FLAG_COUNTER_HEIGHT)
)
self._screen.fill(Color('light grey'))
# Cheat Mode button
self.CHEATMODE_WIDTH = math.floor(self.WIDTH/3)
self._cheatMode = self._screen.subsurface(
Rect(self.MARGIN + self.BUTTON_WIDTH + self.MARGIN + self.TIMER_WIDTH + self.MARGIN, self.MARGIN, self.CHEATMODE_WIDTH, self.HEADER_BAR-self.MARGIN)
)
display.flip()
def __init__(self):
self.screen = display.set_mode((500, 650))
display.set_mode((500, 650))
display.set_caption("#BakerChallenge")
self.scene = None
self.quit_flag = False
self.clock = time.Clock()
def init():
global RsScreen, RsRoom
pygame.init()
PyDisplay.init()
PyDisplay.set_caption("Real Space")
PyDisplay.set_allow_screensaver(False)
RsScreen = PyDisplay.set_mode(RsConstants.Resolutions)
# Startup
Game.init()
Rooms = RsContainers.RoomOrder
RsRoom = Rooms[0]
if not RsRoom:
raise RuntimeError("No scene found.")
absolute_timer = Clock()
# Load rooms
print(RsRoom)
RsRoom.onAwake()
while True:
frame_time: int = 0 if RsRoom.paused else absolute_timer.get_time()
RsScreen.fill(RsConstants.c_black)
asyncio.run(event_collect())
asyncio.run(scene_update(RsRoom, frame_time))
PyDisplay.flip()
absolute_timer.tick()
def __init__(self, state):
"""
Args:
state ('dict of class:Pokemon'): A dictionary with all the
information needed to display
the a battle.
Note: This dict have as key: "Ally_0", "Ally_1", "Foe_0"
and "Foe_1" with the corresponding pokemon as a value.
Action:
Create and execute a window where the 'state' of a battle
is displayed.
"""
pygame.init()
width, height = Display_Config['BATTLE_SIZE']
height += Display_Config['LOG_SIZE'][1]
height += Display_Config['SELECT_SIZE'][1]
if state['use_agent'] and Display_Config['VISUALIZE_AGENT_INFO']:
width *= 2
SCREEN_SIZE = (width, height)
self.SCREEN = display.set_mode(scale(SCREEN_SIZE))
display.set_icon(load_image(Directory['ICON_FILE']))
display.set_caption(Display_Config['TITLE'])
self.battle = Battle_display(state)
self.dialog = Dialog_display()
self.select = Selection_Manager(state)
self.visualize_items = [self.battle, self.dialog, self.select]
if Display_Config["PLAY_MUSIC"]: Song().play()
if state['use_agent'] and Display_Config['VISUALIZE_AGENT_INFO']:
self.visualize_items.append(Stats_display(state))
self.visualize_items.append(Moves_display(state))
def game_loop():
"""Ciclo de juego. Mientras no se cierre la ventana, el juego no
termina."""
pantalla = set_mode((ANCHO, ALTO))
set_caption("Pong <3")
fondo = cargar_imagen('images/fondo_pong.png')
bola = Bola()
pala = Pala(30, imagen="images/amlo.jpg")
pala_cpu = Pala(ANCHO - 30, 0.3, "images/trump.jpg")
clock = Clock()
puntos = [0, 0]
sonido = Sound('audios/Tetris.ogg')
sonido.play()
while puntos[0] < 30 and puntos[1] < 30:
time = clock.tick(60)
keys = get_pressed()
for eventos in get():
if eventos.type == QUIT:
sys.exit(0)
bola.actualizar(time, pala, pala_cpu, puntos)
pala.mover(time, keys)
pala_cpu.ia(time, bola)
puntos_jug, puntos_jug_rect = texto(
"Jugador Puntos: " + str(puntos[0]), 140, 40)
puntos_cpu, puntos_cpu_rect = texto(
"Maquina Puntos: " + str(puntos[1]), ANCHO - ANCHO / 4, 40)
pantalla.blit(fondo, (0, 0))
pantalla.blit(bola.image, bola.rect)
pantalla.blit(pala.image, pala.rect)
pantalla.blit(pala_cpu.image, pala_cpu.rect)
pantalla.blit(puntos_jug, puntos_jug_rect)
pantalla.blit(puntos_cpu, puntos_cpu_rect)
flip()
return 0
def __init__(self):
init()
self.n = 3
self.planets = {i: PLANET() for i in range(self.n)}
self.cm_velocity_zero()
display.set_caption('Planets')
self.clock = time.Clock()
def __init__(self):
self._files = FileResolver()
# Store keyboard keys and corresponded sounds
self._key_sound = {}
# Load keymap settings
with open(self._files.keymap_path) as f:
self._keymap = yaml.safe_load(f)
# Lower buffer to lower sound delay
mixer.init(44100, -16, 2, 256)
# Set higher channels number, allows to play many sounds
# at the same time without stopping previously started ones
mixer.set_num_channels(20)
# Get any mono font, if no mono fonts use system default
fonts = tuple(filter(lambda txt: 'mono' in txt, font.get_fonts()))
win_font = fonts[0] if fonts else None
font.init()
self._font = font.SysFont(win_font, self.FONT_SIZE)
# Set up the window
win_height = len(self._keymap) * self.FONT_SIZE + 2 * self.MARGIN
self._screen = display.set_mode((self.WINDOW_WIDTH, win_height))
display.set_caption(self.WINDOW_CAPTION)
def limit_fps(self, set_caption=True):
t_delta = self._clock.tick(self._fps)
t_raw = self._clock.get_rawtime()
real_fps = int(self._clock.get_fps())
# too much less than 15 FPS and the brain stops pretending it's motion
if real_fps < self._fps - 3 and self._fps > 15:
self._lag += 1
if self._lag > 100:
self._fps /= 2
self._lag = 0
else:
if self._lag >= 0:
self._lag -= 1
# no sense in going over 60 FPS (that i'm aware, anyway)
elif t_raw * 2 < t_delta and self._fps < 60:
self._lag -= 1
else:
self._lag += 1
if self._lag < -100:
self._fps *= 2
self._lag = 0
if set_caption:
display.set_caption('{} fps, targeting {} (lag: {})'.format(
real_fps, self._fps, (self._lag + 5) // 10
))
self._t_delta = t_delta
return t_delta
def start_menu():
from pygame.display import set_mode, list_modes, set_caption
from pygame import init, quit
from pygame.constants import FULLSCREEN
from bin.Controller import process
from obj.Field import Field
init()
screen = set_mode(list_modes()[0], FULLSCREEN)
set_caption("Hero Misadventures")
menu = Menu(("Previous Field", "New Field", "Load Field", "Quit"), screen, surface=color("Lawn Green"),
selection_color=color("Lime Green"), text_color=color("Medium Blue"))
while True:
choose = menu.update()
if choose == 0:
field = Field(screen)
process(screen, field)
elif choose == 1:
from ctypes import cdll
cdll.LoadLibrary("Generator.so").main_generator("res/GENERATOR.HMinf", "res/FIELD.HMmap")
field = Field(screen)
process(screen, field)
elif choose == 2:
from pickle import load
field = load(open("res/SAVE.HMsave", "rb"))
field.screen = screen
process(screen, field)
elif choose == 3:
quit()
return
def open_url(screen, img):
gl.ISURL = 1
num_imgs = len(gl.files)
paint_screen(screen, gl.BLACK)
set_caption("Extract from Web - imgv")
normal_cursor()
show_message(screen, "Enter a Web URL to extract images from", 20, 15, ("transparent"))
gl.URL = ask(screen, "http://")
if gl.URL != None:
gl.files = []
wait_cursor()
show_message(screen, "Loading. Please wait..", 39, 42, ("transparent"))
for ext in gl.IMG_TYPES:
if gl.URL.endswith(ext):
gl.files.append(str("".join(gl.URL)))
return (load_img(gl.files[0], screen), 1)
else:
return (img, num_imgs)
gl.files = []
check_indexhtml()
if gl.URL_ERROR:
gl.files.append(gl.ERROR_IMG)
return (load_img(gl.ERROR_IMG, screen), len(gl.files))
if len(gl.files) < 1:
gl.files.append(gl.ERROR_IMG)
gl.files = [x.replace(" ", "%20") for x in gl.files] # urls need %20 for spaces
return (load_img(gl.files[0], screen), len(gl.files))
def run(self):
#mixer.init()
#mixer.music.load('sound/ACDC.mp3')
#mixer.music.play(-1)
new = NewGame()
new.update()
display.set_caption("Menu")
going = True
while going:
ev = event.poll()
if ev.type == QUIT:
sys.exit()
if ev.type == KEYDOWN and ev.key == K_SPACE:
going = False
if ev.type == MOUSEBUTTONDOWN:
if new.click(mouse.get_pos()):
print("hello world")
going = False
new.mouse_over(mouse.get_pos())
#print "Mouse at : ", mouse.get_pos(), "and rect is : ", new.textpos
Background.render()
new.render()
display.flip()
def on_init(self) -> None:
display.set_caption(LOCALIZATION.game_title)
self.__display_surf = display.set_mode(CONFIG.get_screen_size(),
CONFIG.get_screen_flags())
self.activeScreen().on_init()
def __init__(self, resolution, world, viewport=None):
pgdisplay.init()
self.screen = pgdisplay.set_mode(resolution, pg.DOUBLEBUF)
# self.screen = pgdisplay.set_mode(resolution, pg.DOUBLEBUF|pg.FULLSCREEN)
pgdisplay.set_caption('PyAudioEffect')
self.world = world
self.viewport = viewport
def __init__(self, resolution, world, viewport=None):
pgdisplay.init()
self.screen = pgdisplay.set_mode(resolution, pg.DOUBLEBUF)
# self.screen = pgdisplay.set_mode(resolution, pg.DOUBLEBUF|pg.FULLSCREEN)
pgdisplay.set_caption('PyAudioEffect')
self.world = world
self.viewport = viewport
def _create_screen(self, window_title, screen_size):
"""
Create, configure, and return the game screen surface.
"""
screen = display.set_mode(screen_size)
display.set_caption(window_title)
return screen
def main():
pygame.init()
display.set_caption("Game of Life")
grid_size = (50, 40)
game = Game(grid_size, display)
game.run_game_loop(pygame.event, pygame.time.set_timer)
def __init__(self, arbalet, sim_height, sim_width):
Thread.__init__(self)
self.arbalet = arbalet
self.sim_width = sim_width
self.sim_height = sim_height
self.border_thickness = 1
self.cell_height = sim_width / arbalet.width
self.cell_width = sim_height / arbalet.height
self.rate = Rate(arbalet.config['refresh_rate'])
display.set_caption("Arbalet simulator", "Arbalet")
if get_extended():
try:
self.icon = load_extended(join(dirname(__file__), 'icon.png'))
except error:
raise
else:
display.set_icon(self.icon)
environ['SDL_VIDEO_CENTERED'] = '1'
print("Launching simulator %dx%d " % (self.sim_width, self.sim_height))
with self.arbalet.sdl_lock:
self.display = display.set_mode([self.sim_width, self.sim_height],
0, 32)
self.running = False
self.start()
def constructAllDisplayLists(self):
display.set_caption("PLEASE WAIT... CONSTRUCTING DISPLAY LISTS...")
numKeys = len( self.objs.keys() )
count = 0
for key in self.objs.keys():
gl_utils.glClear(\
gl_utils.GL_COLOR_BUFFER_BIT | gl_utils.GL_DEPTH_BUFFER_BIT)
count = count + 1
numVertices = len( self.objs[key].vertices )
# Construct string:
printStr = "Display list [" + str(count) + "/" + \
str(numKeys) + "]: \"" + str(key) + "\" ("
if self.objs[key].isMatlabBody:
printStr = printStr + "Matlab "
else:
printStr = printStr + "fixed "
printStr = printStr + "body with: " + \
str(numVertices) + " vertices)"
gl_utils.printText(0.15, 0.5, printStr)
display.flip() # update screen, show text
print " --> " + printStr # console message
self.objs[ key ].makeDisplayList() # construct this list
def help_window():
global run_help
size = [1000, 720]
screen = display.set_mode(size)
display.set_caption("Help")
display.set_icon(pygame.image.load("images/help/help.png"))
clock = pygame.time.Clock()
fps = 60
x = 880
y = 600
image_ok_global = pygame.image.load("images/help/ok.png")
image_ok = pygame.transform.scale(image_ok_global, (110, 110))
# mixer.music.load("images/audio/music.mp3")
# mixer.music.play()
image_global = pygame.image.load("images/help/asteroid.jpg")
image = pygame.transform.scale(image_global, (size))
font = pygame.font.SysFont("arial", 20)
text1 = font.render("Hello. The rules of the game are as follows:", True,
(255, 255, 255))
text2 = font.render("1. You have 3 lives", True, (255, 255, 255))
text3 = font.render(
"2. You have to catch meteorites with the numbers you choose", True,
(255, 255, 255))
text4 = font.render("3. To catch, left-click on the meteorite", True,
(255, 255, 255))
text5 = font.render(
"4. If not guessed, the planet explodes, if a meteorite with the correct number falls to earth, it also explodes",
True, (255, 255, 255))
text6 = font.render("5. each correct answer +1 point", True,
(255, 255, 255))
run_help = True
while run_help:
screen.blit(image, (0, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT:
run_help = False
pygame.quit()
quit()
if event.type == pygame.MOUSEBUTTONDOWN:
position = pygame.mouse.get_pos()
if position[0] >= x and position[1] >= y:
if position[0] <= x + 110 and position[1] <= y + 110:
run_help = False
# game_intro()
screen.blit(text1, (0, 0))
screen.blit(text2, (0, 30))
screen.blit(text3, (0, 60))
screen.blit(text4, (0, 90))
screen.blit(text5, (0, 120))
screen.blit(text6, (0, 150))
screen.blit(image_ok, (x, y))
clock.tick(fps)
display.update()
game_intro()
def set_mode(self):
#modes = display.list_modes()
#self.display_surface = display.set_mode(modes[0], self.get_flags())
self.display_surface = display.set_mode((800,600), self.get_flags())
self.width = self.display_surface.get_width()
self.height = self.display_surface.get_height()
display.set_caption("Woger the Wibbly Wobbly Wombat")
def test_caption_unicode(self):
TEST_CAPTION = u'台'
display.set_caption(TEST_CAPTION)
import sys
if sys.version_info.major >= 3:
self.assertEqual(display.get_caption()[0], TEST_CAPTION)
else:
self.assertEqual(unicode_(display.get_caption()[0], 'utf8'), TEST_CAPTION)
def __initPython(self, windowSize):
self.__windowSize = windowSize
self.__window = display.set_mode(self.__windowSize)
display.set_caption("Atlas Chronicle Game Engine")
self.__screen = display.get_surface()
self.__canvas = Surface(self.__windowSize)
def command_hide(screen, new_img, rect, file, num_imgs):
"hide the image by making the screen blank"
(screen, before_winsize, not_accepted) = adjust_screen(screen, NOFRAME)
set_caption("")
hide(screen)
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, num_imgs)
def __initPython(self, windowSize):
self.__windowSize = windowSize
self.__window = display.set_mode(self.__windowSize)
display.set_caption("Fractal Engine")
self.__screen = display.get_surface()
self.__canvas = Surface(self.__windowSize)
self.__canvas.fill((100,100,100))
def __init__(self, game):
self.game = game
self.viewport = None
display.init()
font.init()
self.fonter = font.SysFont('monospace', 16)
self.screen = display.set_mode((config.screenW, config.screenH), DOUBLEBUF, 32)
display.set_caption("Smash the tanks!")
def pause(screen):
while 1:
set_caption("[Slideshow Paused] - imgv")
ren_rect = show_message(screen, "Paused", 30, 23, ("bold"))
event = pygame.event.wait()
check_quit(event)
if event.type == KEYDOWN and event.key not in(K_LALT, K_RALT, K_LCTRL, K_RCTRL, K_TAB):
set_caption("Slideshow = imgv")
paint_screen(screen, gl.BLACK, ren_rect)
break
def command_four(screen, file, new_img):
gl.MULTI_VIEWING = 1
paint_screen(gl.IMGV_COLOR)
set_caption("Four at a time - imgv")
(file, new_img) = four(screen, file, new_img)
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
pygame.event.set_blocked(MOUSEMOTION) # without this the hovers don't work right
gl.MULTI_VIEWING = 0
return (file, new_img, new_img, new_img, rect)
def init_screen(self):
screen_info = display.Info()
self.desktop_width = screen_info.current_w
self.desktop_height = screen_info.current_h
self.get_screen_size()
display.set_icon(load_image(self.main_path, 'iancraft.ico',
convert=False))
self.screen = display.set_mode((self.sw, self.sh), self.flags)
display.set_caption('IanCraft')
def command_help(screen, new_img, file, rect, num_imgs):
(screen, before_winsize, not_accepted) = adjust_screen(screen)
set_caption("Help [imgv v3.1.6]")
help(screen)
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, screen, rect, file, len(gl.files))
def __init__(self):
init()
self.n = 0
self.balls = []
self.player = PLAYER()
self.target = TARGET()
self.target.new()
display.set_caption('Ball Game')
self.clock = time.Clock()
self.Font = font.SysFont("arial", 40);
def command_help(screen, new_img, file, rect):
(screen, before_winsize, not_accepted) = adjust_screen(screen)
set_caption("Help [imgv v%s]" % gl.IMGV_VERSION)
help(screen)
screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, rect)
rect = get_center(screen, new_img)
my_update_screen(new_img, rect, file)
def __init__(self, interval, fps, num_enemies):
self.interval = interval
self.fps = fps
self.num_enemies=num_enemies
PG.init()
self.screen = PD.set_mode((800, 600))
self.screen_rect = self.screen.get_rect()
self.screen.fill((255,255,255))
PD.set_caption("Master Chef's wicked adventure with his ice cream buddies")
#camera handling
total_level_width = 1600
total_level_height = 1200
#camera is the class, cam is our object
self.cam = Camera(camera.complex_camera, total_level_width, total_level_height)
#camera handling end
self.fps = fps
self.speed = 4*self.fps
#sprite group containing all sprites
self.all_sprites = PS.Group()
#Initialize objects on screen----------------
self.character = Player(self.speed)
self.all_sprites.add(self.character)
# bad = Enemy()
#self.charrect = self.character.image_rect
# badrect = bad.image.get_rect()
#create enemy group
self.enemy_list = PS.Group()
#add all the enemies to the list of enemies
for e in range(num_enemies):
enemy = Enemy(self.screen, self.speed)
self.enemy_list.add(enemy)
# self.all_sprites.add(enemy)
#get block sprite group from the map file
self.block_group = Draw.get_block_group('mapfile.txt')
#add the blocks to the sprite group containing all sprites
for block in self.block_group:
self.all_sprites.add(block)
#I don't actually know what this does
PE.set_allowed([QUIT, KEYDOWN])
self.clock = PT.Clock()
self.current_time = PT.get_ticks()
self.updates = 0
self.interval = interval
Locals.CHANGESTATE = 'Game'
def __init__(self, SCREEN):
# Initiate pygame and display.
init()
display.init()
display.set_caption('The Platformer')
# Create fps and set main display.
self.fpsClock = time.Clock()
self.mainDisplay = display.set_mode(SCREEN)
# Level
self.level_1 = Level()
def create_game(self):
"""Initializes the game."""
os.environ['SDL_VIDEO_CENTERED'] = '1'
self.screen = display.set_mode(RESOLUTION, False, 32)
self.scene = Scene(self.screen)
self.events = EventManager(self.scene)
self.clock = time.Clock()
display.set_caption("%s %s" % (NAME, VERSION))
mouse.set_visible(False)
if FULLSCREEN:
toggle_fullscreen()
def __init__(self, size, caption, icon_caption):
pygame.init()
display.set_caption(caption, icon_caption)
self._make_screen(size)
self._controls = []
self._sprites = Group()
self._drag_start = None
self.dragged = lambda start, end: None
self.size_changed = lambda size: None
def play(self, caption="sc8pr", icon=None, mode=True):
"Initialize pygame and run the main drawing / event handling loop"
# Initialize
pygame.init()
self._clock = pygame.time.Clock()
pygame.key.set_repeat(400, 80)
_pd.set_caption(caption)
try:
try: icon = pygame.image.load(icon)
except: icon = Image.fromBytes(sc8prData("alien")).image
_pd.set_icon(icon)
except: logError()
w, h = self._size
self._fixedAspect = w / h
mode = self._pygameMode(mode)
self._mode = mode
self.image = _pd.set_mode(self._size, mode)
self.key = None
self.mouse = pygame.event.Event(pygame.USEREVENT,
code=None, pos=(0,0), description="Sketch startup")
# Run setup
try:
if hasattr(self, "setup"): self.setup()
else:
main = sys.modules["__main__"]
if hasattr(main, "setup"): main.setup(self)
except: logError()
# Drawing/event loop
while not self.quit:
try:
self.frameCount += 1
br = self.dirtyRegions
flip = br is None
self.draw()
if not flip:
br += self.dirtyRegions
flip = self._largeArea()
self._clock.tick(self.frameRate)
if flip: _pd.flip()
else: _pd.update(br)
if self.capture is not None: self.capture.capture(self)
if self.ondraw: self.ondraw()
self._evHandle()
except: logError()
pygame.quit()
mod = sys.modules.get("sc8pr.text")
if mod: mod.Font.dumpCache()
return self
def __init__(self):
"""Creates new MainUI object
state - state to be visualized
"""
pygame.init()
display.set_caption("Snake Game")
self.surface = display.set_mode((1200, 650))
self.fpsClock = time.Clock()
self.state = None
self.frame = 0
self.green_color = Color(0, 200, 0)
def hover_fx(screen, x, cursor):
flag = 0
for it in x:
if it[0].collidepoint(cursor):
flag = 1
gl.OLD_CAP = it[1] + " - imgv"
if gl.OLD_CAP != get_caption()[0]:
set_caption(gl.OLD_CAP)
break
if not flag:
gl.OLD_CAP = "Image Browser - imgv"
if gl.OLD_CAP != get_caption()[0]:
set_caption(gl.OLD_CAP)
