def main():
# Create the main window
window = Window(800, 600, visible=False,
caption="FF:Tactics.py", style='dialog')
# Create the default camera and have it always updating
camera = Camera((-600, -300, 1400, 600), (400, 300), 300, speed=PEPPY)
clock.schedule(camera.update)
# Load the first scene
world = World(window, camera)
world.transition(MainMenuScene)
# centre the window on whichever screen it is currently on
window.set_location(window.screen.width/2 - window.width/2,
window.screen.height/2 - window.height/2)
# clear and flip the window
# otherwise we see junk in the buffer before the first frame
window.clear()
window.flip()
# make the window visible at last
window.set_visible(True)
# finally, run the application
pyglet.app.run()
def main():
# Create the main window
window = Window(800,
600,
visible=False,
caption="FF:Tactics.py",
style='dialog')
# Create the default camera and have it always updating
camera = Camera((-600, -300, 1400, 600), (400, 300), 300, speed=PEPPY)
clock.schedule(camera.update)
# Load the first scene
world = World(window, camera)
world.transition(MainMenuScene)
# centre the window on whichever screen it is currently on
window.set_location(window.screen.width / 2 - window.width / 2,
window.screen.height / 2 - window.height / 2)
# clear and flip the window
# otherwise we see junk in the buffer before the first frame
window.clear()
window.flip()
# make the window visible at last
window.set_visible(True)
# finally, run the application
pyglet.app.run()
class Gameloop(object):
def __init__(self):
self.window = None
def init(self):
self.world = World()
self.world.init()
populate(self.world)
bitmaps = Bitmaps()
bitmaps.load()
self.render = Render(bitmaps)
self.camera = Camera(zoom=10.0)
self.window = Window(fullscreen=False, visible=False)
self.window.set_exclusive_mouse(True)
self.window.on_draw = self.draw
self.window.on_resize = self.render.resize
self.controls = Controls(self.world.bat)
self.window.set_handlers(self.controls)
self.render.init()
clock.schedule(self.update)
self.hud_fps = clock.ClockDisplay()
self.window.set_visible()
def update(self, dt):
# scale dt such that the 'standard' framerate of 60fps gives dt=1.0
dt *= 60.0
# don't attempt to compensate for framerate of less than 30fps. This
# guards against huge explosion when game is paused for any reason
# and then restarted
dt = min(dt, 2)
self.controls.update()
self.world.update()
self.window.invalid = True
def draw(self):
self.window.clear()
self.camera.world_projection(self.window.width, self.window.height)
self.camera.look_at()
self.render.draw(self.world)
self.hud_fps.draw()
return EVENT_HANDLED
def stop(self):
if self.window:
self.window.close()
class Application(object):
def __init__(self):
self.win = None
self.music = None
self.vsync = (
not settings.has_option('all', 'vsync') or
settings.getboolean('all', 'vsync')
)
def launch(self):
self.win = Window(
width=1024, height=768,
vsync=self.vsync,
visible=False)
self.win.set_mouse_visible(False)
GameItem.win = self.win
load_sounds()
self.music = Music()
self.music.load()
self.music.play()
keystate = key.KeyStateHandler()
self.win.push_handlers(keystate)
game = Game(keystate, self.win.width, self.win.height)
handlers = {
key.M: self.toggle_music,
key.F4: self.toggle_vsync,
key.ESCAPE: self.exit,
}
game.add(KeyHandler(handlers))
render = Render(game)
render.init(self.win)
game.startup(self.win)
self.win.set_visible()
pyglet.app.run()
def toggle_vsync(self):
self.vsync = not self.vsync
self.win.set_vsync(self.vsync)
def toggle_music(self):
self.music.toggle()
def exit(self):
self.win.has_exit = True
def main():
win = Window(fullscreen=True, visible=False)
camera = Camera(win.width, win.height, (0, 0), 100)
renderer = Renderer()
maze = Maze()
maze.create(50, 30, 300)
keyboard = Keyboard()
keyboard.key_handlers[key.ESCAPE] = win.close
keyboard.key_handlers.update(camera.key_handlers)
clock.schedule(maze.update)
win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
win.on_key_press = keyboard.on_key_press
keyboard.print_handlers()
win.set_visible()
app.run()
def main():
win = Window(fullscreen=True, visible=False)
camera = Camera(win.width, win.height, (0, 0), 100)
renderer = Renderer()
maze = Maze()
maze.create(50, 30, 300)
keyboard = Keyboard()
keyboard.key_handlers[key.ESCAPE] = win.close
keyboard.key_handlers.update(camera.key_handlers)
clock.schedule(maze.update)
win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
win.on_key_press = keyboard.on_key_press
keyboard.print_handlers()
win.set_visible()
app.run()
class PygletApp(object):
def __init__(self):
self.window = Window(visible=False, fullscreen=False)
self.window.on_resize = self.on_resize
self.window.on_draw = self.on_draw
self.window.on_key_press = self.on_key_press
self.files = SvgFiles()
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
gluLookAt(
0.0, -0.0, 1.0, # eye
0.0, -0.0, -1.0, # lookAt
0.0, 1.0, 0.0) # up
def on_draw(self):
glClear(GL_COLOR_BUFFER_BIT)
self.files.draw()
return EVENT_HANDLED
def on_resize(self, width, height):
# scale is distance from screen centre to top or bottom, in world coords
scale = 110
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
aspect = width / height
gluOrtho2D(
-scale * aspect,
+scale * aspect,
-scale,
+scale)
return EVENT_HANDLED
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE:
self.window.close()
return
self.files.next()
def run(self):
self.window.set_visible()
app.run()
class PygletApp(object):
def __init__(self):
self.window = Window(visible=False, fullscreen=False)
self.window.on_resize = self.on_resize
self.window.on_draw = self.on_draw
self.window.on_key_press = self.on_key_press
self.files = SvgFiles()
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
gluLookAt(
0.0, -0.0, 1.0, # eye
0.0, -0.0, -1.0, # lookAt
0.0, 1.0, 0.0) # up
def on_draw(self):
glClear(GL_COLOR_BUFFER_BIT)
self.files.draw()
return EVENT_HANDLED
def on_resize(self, width, height):
# scale is distance from screen centre to top or bottom, in world coords
scale = 110
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
aspect = width / height
gluOrtho2D(
-scale * aspect,
+scale * aspect,
-scale,
+scale)
return EVENT_HANDLED
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE:
self.window.close()
return
self.files.next()
def run(self):
self.window.set_visible()
app.run()
def test_set_visible(self):
w = Window(200, 200)
try:
w.push_handlers(WindowEventLogger())
w.dispatch_events()
self.user_verify('Is the window visible?', take_screenshot=False)
w.set_visible(False)
w.dispatch_events()
self.user_verify('Is the window no longer visible?',
take_screenshot=False)
w.set_visible(True)
w.dispatch_events()
self.user_verify('Is the window visible again?',
take_screenshot=False)
finally:
w.close()
win = Window(fullscreen=True, visible=False)
camera = Camera((0, 0), 10)
renderer = Renderer()
army_shape = Army.MakeShape(400, 1500, all_ghosts)
armies = []
for i in range(20, 0, -1):
army = Creature(army_shape, rand_point(500), uniform(-pi, pi))
army.dx = uniform(-0.4, +0.4)
army.dy = uniform(-0.4, +0.4)
armies.append(army)
def update(dt):
for army in armies:
army.update(dt)
camera.zoom(1.003)
clock.schedule(update)
key_handlers[key.ESCAPE] = win.close
win.on_draw = lambda: renderer.on_draw(armies, camera, win.width, win.height)
win.on_key_press = on_key_press
print "keys to try:", [symbol_string(k) for k in key_handlers.keys()]
stdout.flush()
win.set_visible()
app.run()
def on_key_press(symbol, modifiers):
if symbol == key.BACKSPACE:
interp.backspace()
else:
return True
window.push_handlers(on_key_press)
def blink_cursor(dt):
cursor = layout.document.get_element('cursor')
if cursor.style['background-color']:
del cursor.style['background-color']
else:
cursor.style['background-color'] = 'black'
clock.schedule_interval(blink_cursor, 0.5)
glClearColor(1, 1, 1, 1)
window.set_visible()
while not window.has_exit:
window.dispatch_events()
clock.tick()
glClear(GL_COLOR_BUFFER_BIT)
layout.draw()
window.flip()
class Gameloop(object):
def __init__(self, options):
self.options = options
self.window = None
self.fpss = []
self.time = 0.0
self.level = None
def prepare(self, options):
self.window = Window(
fullscreen=options.fullscreen,
vsync=options.vsync,
visible=False,
resizable=True)
self.window.on_draw = self.draw_window
self.world = World()
self.player = Player(self.world)
self.camera = GameItem(
position=origin,
update=CameraMan(self.player, (3, 2, 0)),
)
self.level_loader = Level(self)
success = self.start_level(1)
if not success:
logging.error("ERROR, can't load level 1")
sys.exit(1)
self.update(1/60)
self.window.push_handlers(KeyHandler(self.player))
self.render = Render(self.world, self.window, self.camera)
self.render.init()
self.music = Music()
self.music.load()
self.music.play()
def run(self):
pyglet.clock.schedule(self.update)
self.window.set_visible()
self.window.invalid = False
pyglet.app.run()
def update(self, dt):
if self.options.print_fps:
self.fpss.append(1/max(1e-6, dt))
dt = min(dt, 1 / 30)
self.time += dt
for item in self.world:
if hasattr(item, 'update'):
item.update(item, dt, self.time)
if self.player_at_exit():
self.world.remove(self.player)
pyglet.clock.schedule_once(
lambda *_: self.start_level(self.level + 1),
1.0
)
self.window.invalid = True
def start_level(self, n):
success = self.level_loader.load(self.world, n)
if not success:
logging.info('No level %d' % (n,))
self.stop()
return False
self.level = n
pyglet.clock.schedule_once(
lambda *_: self.world.add(self.player),
2.0,
)
return True
def player_at_exit(self):
items = self.world.collision.get_items(self.player.position)
if any(hasattr(item, 'exit') for item in items):
dist2_to_exit = dist2_from_int_ords(self.player.position)
if dist2_to_exit < EPSILON2:
return True
return False
def draw_window(self):
self.window.clear()
self.render.draw_world()
if self.options.display_fps:
self.render.draw_hud()
self.window.invalid = False
return EVENT_HANDLED
def stop(self):
if self.window:
self.window.close()
if self.options.print_fps:
print ' '.join("%6.1f" % (dt, ) for dt in self.fpss)
def play():
back_image1 = pyglet.resource.image('resources/1.jpg') ##Cream Box
back_image2 = pyglet.resource.image('resources/2.png') ##Black Box
red_queen = pyglet.resource.image("resources/queen_red.png") ##Red queen
queen = pyglet.resource.image(
"resources/queen.png") ##Queen which is being placed on the board
cursor_image = pyglet.resource.image(
"resources/Snowball_Cursor.png") ##Spot Cursor
Chess_Window = Window(
back_image1.width * (number_queens),
back_image2.height * (number_queens),
resizable=False, # Make sure it is not resizable
caption="*** N QUEENS ***", # Caption of window
config=pyglet.gl.Config(double_buffer=True), # Avoids flickers
vsync=False # For flicker-free animation
) # Calling base class constructor
Chess_Window.set_visible(False) #The main window for the game
global queen_sprite, cursor_sprite, red_queen_sprite
cimage = pyglet.image.load(("resources/cursor.png"))
cursor = pyglet.window.ImageMouseCursor(cimage, 0, 50)
Chess_Window.set_mouse_cursor(cursor)
queen_sprite = [[0 for x in range(number_queens)]
for y in range(number_queens)]
cursor_sprite = [[0 for x in range(number_queens)]
for y in range(number_queens)]
red_queen_sprite = [[0 for x in range(number_queens)]
for y in range(number_queens)]
def sprite(
): #spreading the images over the constructed nxn matrix. One for each type of icon/image
global number_queens, queen_sprite, cursor_sprite, red_queen_sprite
queen_sprite = [[0 for x in range(number_queens)]
for y in range(number_queens)]
cursor_sprite = [[0 for x in range(number_queens)]
for y in range(number_queens)]
red_queen_sprite = [[0 for x in range(number_queens)]
for y in range(number_queens)]
for i in range(number_queens):
for j in range(number_queens):
queen_sprite[j][i] = (pyglet.sprite.Sprite(
queen, (j * 60), (i * 60)))
red_queen_sprite[j][i] = (pyglet.sprite.Sprite(
red_queen, (j * 60), (i * 60)))
cursor_sprite[j][i] = (pyglet.sprite.Sprite(
cursor_image, (j * 60), (i * 60)))
queen_sprite[j][i].visible = False
cursor_sprite[j][i].visible = False
red_queen_sprite[j][i].visible = False
def resize(
): #resizing the chess window according to selected number of queens
Chess_Window.set_size(back_image1.width * (number_queens + 2),
back_image2.height * (number_queens))
Chess_Window.set_visible(True)
def on_mouse_motion(
x, y, dx, dy
): #for appearance of bulls-eye cursor on chess board when mouse is kept within chess board
global cursor_co
for index_11 in range(number_queens):
for index_12 in range(number_queens):
if (index_12 * 60 <= x <
(index_12 + 1) * 60) and (index_11 * 60 <= y <
(index_11 + 1) * 60):
cursor_sprite[index_12][index_11].visible = True
cursor_co = (index_12, index_11)
else:
cursor_sprite[index_12][index_11].visible = False
def queen_checker(
): #function that checks for queens in forbidden area. Highlights the wrongly placed queens and
#runs on every click
global number_queens, queen_sprite, cursor_sprite, red_queen_sprite
for y in range(number_queens): #y is row number
for x in range(number_queens): #x is column numer
if queen_sprite[x][
y].visible == True: ##Check if Queen is placed somewhere
for ind in range(number_queens):
##Checks if no queen is already placed in the same row
if ind != x: #consider ind as column number
if queen_sprite[ind][y].visible:
red_queen_sprite[ind][y].visible = True
red_queen_sprite[x][y].visible = True
danger = True
##Checks if no queen is already placed in the same column
if ind != y: #consider ind as row number
if queen_sprite[x][ind].visible:
red_queen_sprite[x][ind].visible = True
red_queen_sprite[x][y].visible = True
danger = True
if ind > 0:
if x + ind <= (number_queens - 1) and y + ind <= (
number_queens -
1): ##for the secondary diagonal
if queen_sprite[x + ind][ind + y].visible:
red_queen_sprite[ind + x][ind +
y].visible = True
red_queen_sprite[x][y].visible = True
danger = True
if x + ind <= (
number_queens - 1
) and y - ind >= 0: ##for the main diagonal
if queen_sprite[x + ind][y - ind].visible:
red_queen_sprite[x +
ind][y -
ind].visible = True
red_queen_sprite[x][y].visible = True
danger = True
def replay(
): #function for setting all variables to initial stages and replaying game from start.
global win
global danger
for c in range(number_queens):
for d in range(number_queens):
queen_sprite[d][
c].visible = False ##No queen is placed on the board
cursor_sprite[d][
c].visible = False ##No cursor sprite visible at the start
red_queen_sprite[d][
c].visible = False ##No error sprite appears
del Queen_Storage[:] ##deleting all the members of the list
danger = False ##No Queen then in danger
win = False ##Not won the game
@Chess_Window.event()
def on_mouse_press(x, y, button, modifiers):
global number_queens, win, danger, Queen_Storage, queen_sprite, cursor_sprite, red_queen_sprite, cursor_co
if x >= 0 and x <= (
number_queens *
60): # loops running within the dimensions of the chessboard
if y >= 0 and y <= (number_queens * 60):
if button == mouse.LEFT: ## if left mouse button is clicked
if not win: ##Only allows execution of game is not won after starting it. Once won it stops working until play again execution.
for v in range(number_queens):
for w in range(number_queens):
if (w * 60 <= x <
(w + 1) * 60) and (v * 60 <= y <
(v + 1) * 60):
if queen_sprite[w][
v].visible != True: ##Checking if queen is already not placed
if len(Queen_Storage) > (
(number_queens) - 1
): ##Don't allow the placement of queens of the number exceed the 8.
queen_sprite[w][v].visible = False
else:
queen_sprite[w][v].visible = True
Queen_Storage.append(
queen_sprite[w][v].visible
) ##If queen is added to the board then it is also added to storage
#print("Queen on Board: ", Queen_Storage) ##print the number of queens on board on console
#print("Queen added at box (" + str(w+1) + "," + str(v+1) + ")\n") ##print the coordinates for the queen on console
else:
queen_sprite[w][
v].visible = False #if queen is already placed, then making dissapear.
Queen_Storage.pop(
) ##If queen is removed from the board then it is also deleted from the storage
for index1 in range(number_queens):
for index2 in range(
number_queens
): #setting all error queens to invisible so that each queen be checked
red_queen_sprite[index2][
index1].visible = False
danger = False
queen_checker()
elif x > (number_queens * 60):
if y >= 123 and y <= 180:
danger = False
win = False
Queen_Storage = []
number_queens = 0
queen_sprite, cursor_sprite, red_queen_sprite = 0, 0, 0
cursor_co = (0, 0)
Chess_Window.close()
elif y >= 229 and y <= 281:
replay()
@Chess_Window.event
def on_mouse_motion(
x, y, dx, dy
): #for appearance of bulls-eye cursor on chess board when mouse is kept within chess board
global cursor_co
for index_11 in range(number_queens):
for index_12 in range(number_queens):
if (index_12 * 60 <= x <
(index_12 + 1) * 60) and (index_11 * 60 <= y <
(index_11 + 1) * 60):
cursor_sprite[index_12][index_11].visible = True
cursor_co = (index_12, index_11)
else:
cursor_sprite[index_12][index_11].visible = False
def on_draw2(
): #function for making visible the chess board and icons/images related to it
global main
global number_queens, queen_sprite, cursor_sprite, red_queen_sprite
Chess_Window.clear()
game_options = pyglet.sprite.Sprite(
pyglet.image.load(("resources/game_options.jpg")),
60 * (number_queens), 0)
tile1 = back_image1 ##Setting images to new variables
tile2 = back_image2
for index_1 in range(
number_queens): ##Nested loops to draw total nxn boxes
for index_2 in range(number_queens):
if number_queens % 2 == 0:
if index_1 % 2 == 0:
tile1.blit(index_1 * 60,
index_2 * 60) ##Drawing Tile2 image
tile1, tile2 = tile2, tile1 ##Swaping the tiles
else:
tile2.blit(index_1 * 60,
index_2 * 60) ####Drawing Tile1 image
tile1, tile2 = tile2, tile1
else:
if index_1 % 1 == 0:
tile1.blit(index_1 * 60,
index_2 * 60) ##Drawing Tile2 image
tile1, tile2 = tile2, tile1 ##Swaping the tiles
else:
tile2.blit(index_1 * 60,
index_2 * 60) ####Drawing Tile1 image
tile1, tile2 = tile2, tile1
for p in range(
number_queens
): #drawing all the images on the matrix, visible and invisible
for q in range(number_queens):
queen_sprite[q][p].draw()
red_queen_sprite[q][p].draw()
cursor_sprite[q][p].draw()
game_options.draw()
game_options.visible = True
# Updating the Window
def update(d):
on_draw2()
resize()
sprite()
# Se tting the time interval to update
pyglet.clock.schedule_interval(update, 1 / 120)
# Running Pyglet
pyglet.app.run()
def make_army(size, menagerie):
army = []
for col in range(size):
for row in range(size):
creature_type = menagerie[randint(0, len(menagerie)-1)]
x = (col+0.5)*16 - size * 8
y = (row+0.5)*16 - size * 8
creature = Creature(creature_type, (x, y))
creature.da = uniform(-0.1, +0.1)
creature.velocity = uniform(0, +0.5)
army.append(creature)
return army
creatures = make_army(12, [blue_ghost, orange_ghost, pacman, pink_ghost, red_ghost])
def update(dt):
for creature in creatures:
creature.update(dt)
clock.schedule(update)
key_handlers[key.ESCAPE] = win.close
win.on_draw = lambda: renderer.on_draw(creatures, camera, win.width, win.height)
win.on_key_press = on_key_press
print "keys to try:", [symbol_string(k) for k in key_handlers.keys()]
stdout.flush()
win.set_visible()
app.run()
def print_style(style, indent=''):
import textwrap
print '\n'.join(textwrap.wrap(repr(style), initial_indent=indent,
subsequent_indent=indent))
if style.parent:
print_style(style.parent, ' ' + indent)
def print_element(element, indent=''):
import textwrap
print '\n'.join(textwrap.wrap(repr(element), initial_indent=indent,
subsequent_indent=indent))
if element.style_context:
print_style(element.style_context, indent + ' ')
for child in element.children:
print_element(child, ' ' + indent)
glClearColor(1, 1, 1, 1)
window.set_visible()
while not window.has_exit:
clock.tick()
print 'FPS = %.2f\r' % clock.get_fps(),
window.dispatch_events()
glClear(GL_COLOR_BUFFER_BIT)
layout.draw()
window.flip()
class Gameloop(object):
instance = None
def __init__(self):
Gameloop.instance = self
self.window = None
self.camera = None
self.world = None
self.renderer = None
self.paused = False
self.fps_display = None
Keyboard.handlers.update({
key.PAGEUP: lambda: self.camera.zoom(2.0),
key.PAGEDOWN: lambda: self.camera.zoom(0.5),
key.ESCAPE: self.quit_game,
key.PAUSE: self.toggle_pause,
key.F12: lambda: save_screenshot(self.window),
})
def init(self, name, version):
clock.set_fps_limit(FPS_LIMIT)
self.fps_display = clock.ClockDisplay()
self.camera = Camera((0, 0), 800)
self.renderer = Renderer(self.camera)
caption = '%s v%s' % (name, version)
self.window = Window(
caption=caption, fullscreen=True, visible=False)
self.window.on_key_press = on_key_press
self.window.push_handlers(Keyboard.keystate)
graphics = load_graphics()
self.world = World()
builder = LevelBuilder()
seed(1)
builder.build(self.world, 75, graphics)
self.world.player = Player()
self.world.player.add_to_space(self.world.space, (0, 200), 0)
self.world.chunks.update(self.world.player.chunks)
def dispose(self):
if self.window:
self.window.close()
def run(self):
try:
self.window.set_visible()
while not self.window.has_exit:
self.window.dispatch_events()
clock.tick()
if self.world and not self.paused:
self.world.tick(1/FPS_LIMIT)
if self.world and hasattr(self.world, 'player'):
player_position = self.world.player.chunks[0].body.position
self.camera.x, self.camera.y = player_position
self.camera.angle = atan2(
player_position.x,
player_position.y)
self.camera.update()
if self.renderer:
aspect = (
self.window.width / self.window.height)
self.renderer.draw(self.world, aspect)
self.camera.hud_projection(
(self.window.width, self.window.height))
self.fps_display.draw()
self.window.flip()
finally:
self.dispose()
def toggle_pause(self):
self.paused = not self.paused
def quit_game(self):
self.window.has_exit = True
