Exemple #1
0
def start():
    global boidflock

    seed(time.time())

    graphics.init(width=640, height=480)

    graphics.bg_colour(graphics.BLACK)

    #splatter a flock in the space randomly
    def generate_boid():
        x = randrange(0, 640) #random left-right
        y = randrange(0, 480) #random up-down

        position = pygame.math.Vector2(x, y)
        #splat a boid, add to flock list
        velocity = pygame.math.Vector2((random() * 2) - 1, (random() * 2) - 1)
        velocity.scale_to_length(50)

        boidflock.add(boids.Boid(position, velocity))

    for _ in range(50):
        generate_boid()

    for b in boidflock:
        b.image = pygame.Surface((1, 1))
        b.image.fill(graphics.WHITE)

    boidflock.draw(graphics.screen)

    graphics.draw()
Exemple #2
0
def start(argv):
    graphics.assetDirectory('assets')
    sprite = graphics.Sprite("sprite.png", Vector2D(100.0,100.0), frames=9)
    button = GUI.Button("button.png", Vector2D(200.0,100.0))
    def drawFunc():
        sprite.draw()
        button.draw()
        graphics.drawText("Works!", Vector2D(80.0,550.0), Color(0,0,255))
    graphics.init(800, 600, drawFunc)
    inputf.init()
    GUI.init()
    
    def movementMicrothread():
        while True:
            if inputf.keyboard[inputf.key.UP]:
                sprite.position.y += 10 * logic.delta()
            if inputf.mouse.left:
                sprite.position.x += 10 * logic.delta()
            #else:
            #    sprite.position.x -= 10 * logic.delta()
            if inputf.mouse.inRect(sprite):
                sprite.position.y -= 10 * logic.delta()
            microthreads.schedule()
    microthreads.microthread(movementMicrothread)
    
    logic.start()
    
Exemple #3
0
def main():
    global ents, sc, run
    run = True

    graphics.init(con.SCR_WIDTH, con.SCR_HEIGHT)
    sc = score.Score()

    try:
        pygame.mixer.pre_init(44100, -16, 2, 4096)
        pygame.mixer.init()
    except:
        print "You don't have audio support."
        con.audio_support = False

    if con.audio_support:
        audio.load_audio()
        pygame.mixer.music.load(os.path.join('audio', 'jl_music2.ogg'))
        pygame.mixer.music.set_volume(.9)

    while run:
        game_start()
        game_loop()
        game_end()

    pygame.quit()
Exemple #4
0
def init():
    global font, smallfont, bigfont, mediumfont, consolefont
    graphics.init()

    consolefont = load_font(None, 20)
    smallfont = font = load_font(None, 25)
    mediumfont = load_font(None, 32)
    font = bigfont = load_font(None, 50)
def init():
    global font, smallfont, bigfont, mediumfont, consolefont
    graphics.init()

    consolefont = load_font(None, 20)
    smallfont = font = load_font(None, 25)
    mediumfont = load_font(None, 32)
    font = bigfont = load_font(None, 50)
Exemple #6
0
def create_window(size):
    graphics.init()
    fullscreen = features.get('ui.fullscreen')
    if fullscreen:
        size = graphics.get_screen_size()
    graphics.create_window(size, fullscreen=fullscreen)
    if features.get('ui.offscreen'):
        graphics.set_offscreen_window(size)
Exemple #7
0
def main():
	pygame.init()
	pygame.mixer.init()
	sound.setvolume(0)
	pygame.font.init()
	graphics.setmode()
	graphics.init()
	if settings.playback:
		state0, record = cPickle.load(open(data.filepath("record.pkl"), "rb"))
		state.loadobj(state0)
		scene.push(scenes.game if settings.skipmenu else scenes.menu)
	elif settings.restart:
		state.init()
		scene.push(scenes.game if settings.skipmenu else scenes.menu)
	else:
		scene.push(scenes.menu)
		if state.load():
			scene.push(scenes.game)
	clock = pygame.time.Clock()

	if settings.playback:
		for rstate, dt, events, kpress, mpos in record:
			clock.tick(settings.fps)
			s = scene.top()
			random.setstate(rstate)
			if settings.vidcap:
				vidcap._mpos = mpos
			s.think(dt, events, kpress, mpos)
			s.draw(mpos)
			pygame.display.flip()
		return

	if settings.getrecord:
		record = []
		state0 = cPickle.loads(cPickle.dumps(state.saveobj()))
	while scene.top():
		dt = min(0.001 * clock.tick(settings.fps), 0.5)
		if settings.fixfps:
			dt = 1.0 / settings.fps
		s = scene.top()
		while dt > 0:
			tdt = min(dt, 0.1)
			events = map(EventProxy, pygame.event.get())
			kpress = pygame.key.get_pressed()
			mpos = pygame.mouse.get_pos()
			if settings.getrecord:
				record.append((random.getstate(), tdt, events, kpress, mpos))

			s.think(tdt, events, kpress, mpos)
			dt -= tdt
		s.draw(mpos)
		pygame.display.flip()

	graphics.quit()
	
	if settings.getrecord:
		cPickle.dump([state0, record], open(data.filepath("record.pkl"), "wb"))
Exemple #8
0
def run():
    try:
        parser.init()
        stage.init()
        graphics.init()
        theme.init()
        gameloop.start()

    except KeyboardInterrupt:
        exit()
def run():
    try:
        parser.init()
        stage.init()
        graphics.init()
        theme.init()
        gameloop.start()

    except KeyboardInterrupt:
        exit()
Exemple #10
0
def init_screen():
    global screen, surface, overview_surface

    if osutil.is_desktop:
        # on Android android.pyx takes care of init
        graphics.init()
        graphics.create_window((1280, 800))

    screen = graphics.get_window()
    surface = screen
Exemple #11
0
def init_screen():
    global screen, surface, overview_surface

    if osutil.is_desktop:
        # on Android android.pyx takes care of init
        graphics.init()
        graphics.create_window((1280, 800))

    screen = graphics.get_window()
    surface = screen
Exemple #12
0
def init():
    graphics.init()

    ui.consolefont = load_font(None, 20)
    ui.smallfont = font = load_font(None, 25)
    ui.mediumfont = load_font(None, 32)
    ui.font = ui.bigfont = load_font(None, 50)

    if features.get('stream.enable'):
        from . import stream
        stream.init()
Exemple #13
0
def run():
    try:
        # Init the editor
        graphics.init()
        theme.init()

        # Start the editor
        gameloop.start()

    except KeyboardInterrupt:
        exit()
Exemple #14
0
def run():
    try:
        # Init the editor
        graphics.init()
        theme.init()

        # Start the editor
        gameloop.start()

    except KeyboardInterrupt:
        exit()
Exemple #15
0
def run(width=300, height=300):
    def redrawAllWrapper(canvas, data):
        canvas.delete(ALL)
        canvas.create_rectangle(0,
                                0,
                                data.width,
                                data.height,
                                fill='black',
                                width=0)
        graphics.redrawAll(canvas, data)
        canvas.update()

    def mousePressedWrapper(event, canvas, data):
        graphics.mousePressed(event, data)
        redrawAllWrapper(canvas, data)

    def keyPressedWrapper(event, canvas, data):
        graphics.keyPressed(event, data)
        redrawAllWrapper(canvas, data)

    def motionWrapper(event, canvas, data):
        graphics.motion(event, data)
        redrawAllWrapper(canvas, data)

    def timerFiredWrapper(canvas, data):
        graphics.timerFired(data)
        redrawAllWrapper(canvas, data)
        # pause, then call timerFired again
        canvas.after(data.timerDelay, timerFiredWrapper, canvas, data)

    # Set up data and call init
    class Struct(object):
        pass

    data = Struct()
    data.width = width
    data.height = height
    data.timerDelay = 100  # milliseconds
    root = Tk()
    graphics.init(data)
    # create the root and the canvas
    canvas = Canvas(root, width=data.width, height=data.height)
    canvas.configure(bd=0, highlightthickness=0)
    canvas.pack()
    # set up events
    root.bind("<Button-1>",
              lambda event: mousePressedWrapper(event, canvas, data))
    root.bind("<Key>", lambda event: keyPressedWrapper(event, canvas, data))
    root.bind('<Motion>', lambda event: motionWrapper(event, canvas, data))
    timerFiredWrapper(canvas, data)
    # and launch the app
    root.mainloop()  # blocks until window is closed
    print("bye!")
Exemple #16
0
def main():
    global surface,FPSCLOCK
    pygame.init()
    surface = pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT))
    FPSCLOCK = pygame.time.Clock()
    graphics.init(surface)
    board = []
    for i in range(BOARDROWS):
        board.append([BLANK]*BOARDCOLS)
    assert len(board) == BOARDROWS
    for i in range(BOARDROWS):
        assert len(board[i]) == BOARDCOLS
    board[0][0] = TYPE_O
    board[0][1] = TYPE_O
    board[1][0] = TYPE_O
    board[1][1] = TYPE_O

    board[5][5] = TYPE_I
    board[6][5] = TYPE_I
    board[7][5] = TYPE_I
    board[8][5] = TYPE_I

    game.start()
    
    while (True):
        if game.checkGameEnd():
            print 'the game has ended!!'
            FPSCLOCK.tick(FPS)
            continue
        for event in pygame.event.get(QUIT):
            terminate()
        for y in range(BOARDROWS):
            for x in range(BOARDCOLS):
                print game.board[y][x],
            print ''
            
        print 'number of pieces: ',len(game.getPieces())
        #graphics.drawBoard(board)
        graphics.reset()
        for piece in game.getPieces():
            # print 'drawing a piece!!!'
            print piece
            graphics.drawPiece(piece)
        graphics.drawStatus(1000,20)
        pygame.display.update()
        game.update()
        FPSCLOCK.tick(FPS)
Exemple #17
0
def main():
    global FPSCLOCK, DISPLAYSURF, running,SOUND_CLEARLINE
    pygame.init()
    FPSCLOCK = pygame.time.Clock()
    graphics.init()
    pygame.mixer.init(44100, -16, 2, 2048)
    pygame.display.set_caption(GAME_NAME)
    pygame.mixer.music.load('../music/theme.mp3')  # load music theme
    SOUND_CLEARLINE = pygame.mixer.Sound(file='../music/clearline.wav')
    # TODO: need to lead line eating sound
    running = False
    # show main menu or sth

    start()
    run()
    # by now, the game is over
    terminate()
Exemple #18
0
def run():
    try:
        # Init the game
        parser.init()
        # Check for editor
        if (parser.args.editor):
            os.system("/usr/share/make-snake/snake-editor/__main__.py")
            sys.exit(0)
        graphics.init()
        theme.init()
        stage.init()
        game.reset()

        # Start the game
        gameloop.start()

    except KeyboardInterrupt:
        exit()
Exemple #19
0
def run():
    try:
        # Init the game
        parser.init()
        # Check for editor
        if (parser.args.editor):
            os.system("/usr/share/make-snake/snake-editor/__main__.py")
            sys.exit(0)
        graphics.init()
        theme.init()
        stage.init()
        game.reset()

        # Start the game
        gameloop.start()

    except KeyboardInterrupt:
        exit()
Exemple #20
0
def main():
    cap = cv2.VideoCapture(0)
    assert cap.isOpened(), 'failed to open capture'

    _, img = cap.read()
    height, width = img.shape[:2]

    pygame.init()
    pygame.display.set_mode((width, height), DOUBLEBUF | OPENGL)

    graphics.init()

    with np.load('calib.npz') as data:
        cmat, dist = data['mat'], data['dist']

    flag = False
    rvec = np.zeros(3)
    tvec = np.zeros(3)

    while True:
        _, img = cap.read()

        flag, img, rvec, tvec = track(img, cmat, dist, rvec, tvec, flag)

        color = 255 if flag else 100
        # img = axis(img, rvec, tvec, cmat, dist, color)

        graphics.clear()
        graphics.imshow(img)

        if flag:
            graphics.drawteapot(rvec, tvec, cmat, width, height)

        pygame.display.flip()
        pygame.time.wait(17)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                cap.release()
                pygame.quit()
                quit()
Exemple #21
0
# Constants
viewport_size = 600 # This is the height of the viewport
spread = 20 #used to be 20, but i like at 80
active_hollusion = None
lastframe = None
#Setup
import graphics
import math
import time
import PyGif

Posn = graphics.Posn
Rgb = graphics.Rgb
draw_solid_polygon = graphics.draw_solid_polygon

graphics.init(viewport_size)
vp = graphics.open_viewport("ViewPort", 4/3*viewport_size, viewport_size)
lp = graphics.open_pixmap("LeftPort", 4/3*viewport_size, viewport_size)
rp = graphics.open_pixmap("RightPort", 4/3*viewport_size, viewport_size)

def clear_all():
	global active_hollusion
	global vp, lp, rp
	if(active_hollusion != None):
		active_hollusion("kill")
		active_hollusion = None
	graphics.clear_viewport(vp)
	graphics.clear_viewport(lp)
	graphics.clear_viewport(rp)

class Frame:
Exemple #22
0
          Rocks=[]
          
          #Init player data, in validation loop due to init
          player = [Name, Position, Fuel, Civ, Rocks]        
          
          pythonplanet = int(input("Which Planet would you like to make to be the PythonPlanet?\nPlease enter a planet that exists in your import file: "))
          #will raise IndexError if invalid
          print()
          
          graphics = input("Disclaimer: No graphics will be processed if using above 10 planets!\nPlease indicate if you would like to see graphics or not (Y/N): ")
          #IndexError is raised in the resulting function
          print()
          
          try:
              #initialize
              gfx.init(file, presetplanet, planets, player, graphics) #gfx.init loads the file regardless of gfx
              #try raise except this
          except IndexError and FileNotFoundError:
              raise ValueError
          
          if pythonplanet in range(len(planets)):
              gfx.setPythonPlanet(pythonplanet, planets)
          else:
              raise ValueError
          
          break #if reached here, kill validation loop - it is complete
 
      except ValueError:
          print("Hey! Some of those value(s) were incorrect, please enter them again!")
          print()
          continue
def main():
    parser = argparse.ArgumentParser(description='Display a randomized Carcassonne map')
    parser.add_argument('files', metavar='FILE', nargs='*', help='Tile description file (JSON format)')
    parser.add_argument('-d', '--debug', dest='debug_mode', action='store_true', help='Display non-game tiles, etc.')
    parser.add_argument('-n', metavar='N', type=int, dest='max_tiles', default = 0, help='Number of tiles to display (Default: The whole tileset)')
    parser.add_argument('-z', '--zoom-factor', metavar='Z', type=float, dest='zoom_factor', default = 1.0, help='Initial zoom factor (Default: 1.0)')
    parser.add_argument('--draw-all', dest='draw_all', action='store_true', help='Draw all tiles')
    parser.add_argument('-f', '--full-screen', dest='full_screen', action='store_true', help='Full screen')
    parser.add_argument('-s', '--screenshot', dest='take_screenshot', action='store_true', help='Take a screenshot of the final display')
    parser.add_argument('--dump', dest='dump_to_img', action='store_true', help='Dump the final grid to an image')
    parser.add_argument('--river-policy', type=str, dest='river_policy', choices=[policy.name for policy in RiverPlacement], action='append', default=[], help='Placement policies for the river tileset. Can be used multiple times')
    parser.add_argument('--river-period', metavar='P', type=int, dest='river_period', default=1, help='Period of repetition of the river tileset. Set to zero for a single use of the river tileset')
    parser.add_argument('--seed', metavar='INT', type=int, dest='seed', default = 0, help='A seed for the random generator (Default: Use a system generated seed)')
    args = parser.parse_args()

    # Set random seed
    rng_seed = args.seed
    if rng_seed == 0:
        rng_seed = secrets.randbits(64)
    print('Random seed: {}'.format(rng_seed))
    random.seed(rng_seed)

    # Load tileset (JSON files)
    tileset = list(itertools.chain.from_iterable(parse_tileset_description_file(json_file) for json_file in args.files))
    if len(tileset) == 0:
        error('No tiles loaded')

    # River tiles placement policy and period
    river_placement_policies = parse_river_placement_policies([RiverPlacement[policy] for policy in args.river_policy])
    river_tileset_period = args.river_period if args.river_period >= 0 else 0
    if args.debug_mode and any('river' in tile.tags for tile in tileset):
        print('river_placement_policies: {}'.format([policy.name for policy in river_placement_policies]))
        print('river_tileset_period: {}'.format(river_tileset_period))

    try:
        # Load tile images, and draw missing ones
        graphics.init()
        tile_size = load_or_draw_tile_images(tileset, args.draw_all)
        carcassonne_city_tileset, tileset = TileSubset.carcassonne_city().partition_iter(tileset)
        city_start_flag = len(carcassonne_city_tileset) > 0
        river_tileset, regular_tileset = TileSubset.river().partition(tileset)
        del tileset

        # Non-game tiles
        riverside_tile = Tile.from_uniform_color((217, 236, 255), tile_size, 'riverside')
        forbidden_tile = Tile.from_uniform_color((100,  20,  20), tile_size, 'forbidden')
        segment_length_tiles = {
            0: forbidden_tile,
            1: Tile.from_uniform_color((10,  60, 10), tile_size, 'one_side'),
            2: Tile.from_uniform_color((40, 120, 40), tile_size, 'two_sides'),
            3: Tile.from_uniform_color((70, 180, 70), tile_size, 'three_sides')
        }

        # Open display
        (w, h) = (0, 0) if args.full_screen else (1280, 720)
        display = graphics.GridDisplay(w, h, tile_size)
        print('Press ESCAPE in the graphics window to quit', flush = True)

        # Place random tiles. The map must grow!
        candidate_tiles = CandidateTiles(
            on_update = lambda pos_tile: display.set_tile(segment_length_tiles[pos_tile.get_segment_length()].img, pos_tile.pos.x, pos_tile.pos.y) if args.debug_mode else None,
            on_delete = None)
        z = args.zoom_factor
        border = place_carcassonne_city(carcassonne_city_tileset, candidate_tiles, display, z, Vect(-2, -1)) if city_start_flag else Boundary()
        total_nb_tiles_placed = 0
        total_nb_tiles_not_placed = 0
        first_tileset_flag = not city_start_flag
        all_done_flag = False
        for tileset in iterate_tilesets(river_tileset, regular_tileset, river_tileset_period, infinite = (args.max_tiles > 0)):
            for tiles_to_place in shuffle_tileset(tileset, first_tileset_flag, river_placement_policies):
                local_nb_tiles_placed = 0
                while len(tiles_to_place) > 0:
                    tiles_not_placed = []
                    for tile in tiles_to_place:
                        if args.max_tiles > 0 and total_nb_tiles_placed >= args.max_tiles:
                            all_done_flag = True
                            break
                        if len(border) == 0:
                            # The first tile of the map is placed at the center
                            placed_tile = PlacedTile(tile, Vect(0, 0), r = 0)
                        else:
                            forced_segment = 'R' if 'river' in tile.tags and 'source' not in tile.tags else None
                            max_candidates = 1
                            candidate_placements = find_candidate_placements(tile, border, candidate_tiles, max_candidates, forced_segment)
                            placed_tile = select_tile_placement(candidate_placements) if len(candidate_placements) > 0 else None
                        if placed_tile:
                            update_border_and_candidate_tiles(placed_tile, border, candidate_tiles)
                            placed_tile.draw(display)
                            total_nb_tiles_placed += 1
                            local_nb_tiles_placed += 1
                            # z = 0.995 * z
                            # display.update(z, 100)
                        else:
                            tiles_not_placed.append(tile)
                    if all_done_flag:
                        break
                    if len(tiles_not_placed) == len(tiles_to_place):
                        # making no progress, stop there
                        total_nb_tiles_not_placed += len(tiles_not_placed)
                        for tile in tiles_not_placed:
                            warn('Could not place tile: {}'.format(tile))

                        break
                    assert len(tiles_not_placed) < len(tiles_to_place)
                    tiles_to_place = tiles_not_placed

                # Done with the current tiles subset
                if DEBUG_PRINTOUT or args.debug_mode:
                    print('total_nb_tiles_placed: {} (+{})'.format(total_nb_tiles_placed, local_nb_tiles_placed))
                if all_done_flag:
                    break

            # Done with the current tileset
            if all_done_flag:
                break
            first_tileset_flag = False
            display.update(z)

        # Completely done!
        display.update(z)
        print('Done!')
        print('total_nb_tiles_not_placed: {}'.format(total_nb_tiles_not_placed))
        print('total_nb_tiles_placed: {}'.format(total_nb_tiles_placed))
        sys.stdout.flush()

        # Wait until the user quits
        while True:
            display.check_event_queue(200)

    except graphics.MustQuit:
        pass

    finally:
        if args.debug_mode and 'display' in locals():
            print(display.get_debug_info())
        if (args.take_screenshot or args.debug_mode) and 'display' in locals():
            display.take_screenshot(SCREENSHOT_PATH)
            print('Screenshot saved in {}'.format(SCREENSHOT_PATH))
        if args.dump_to_img and 'display' in locals():
            display.dump_to_img(DUMP_PATH, args.zoom_factor)
            print('Dump grid to {}'.format(DUMP_PATH))
        graphics.quit()

    return 0
Exemple #24
0
import pygame

import graphics
import entity
import events

pygame.init()

graphics.init((400, 400))
george = entity.George()
graphics.add(george)

graphics.background = graphics.load("stars.png")


def quit(e):
    global run
    if (e.type == pygame.KEYUP):
        if (e.key == pygame.K_F4 and e.mod & pygame.KMOD_ALT):
            run = False
    elif (e.type == pygame.QUIT):
        run = False


events.register(pygame.QUIT, quit)
events.register(pygame.KEYUP, quit)

events.register(pygame.KEYDOWN, george.key_handler)
events.register(pygame.KEYUP, george.key_handler)

clock = pygame.time.Clock()
Exemple #25
0
 def __init__(self, surf):
     graphics.surf = surf
     graphics.init(amount)
Exemple #26
0
def init_game():
    graphics.init()
    gfx_thread.start()
Exemple #27
0
import graphics
import unit
from random import *

graphics.init()
pygame.mixer.init()

def startScreen():
	global plane, banner, cloud1, cloud2, cloud3, cloud4, run, clock, play, instance

	instance = -1

	graphics.background = graphics.load("images/sky.jpg")

	cloud1 = unit.Cloud(randrange(0, 1400, 10), randint(0, 600))
	graphics.register(cloud1)
	cloud2 = unit.Cloud(randrange(0, 1400, 10), randint(0, 600))
	graphics.register(cloud2)

	banner = unit.Banner(530, 120)
	graphics.register(banner)

	play = unit.Play(560, 200)
	graphics.register(play)

	plane = unit.Plane(800, 100)
	graphics.register(plane)

	cloud3 = unit.Cloud(randrange(0, 1400, 10), randint(0, 600))
	graphics.register(cloud3)
	cloud4 = unit.Cloud(randrange(0, 1400, 10), randint(0, 600))
Exemple #28
0
import pygame, graphics, palette, cursor, toolbar, text, components, wire

graphics.init()
text.init()

class UserInterface:

    def __init__(self):
        self.board = Board(self)
        self.clickables = []    
        self.cursor = cursor.Cursor() 
        
        self.toolbar = toolbar.Toolbar()
        self.toolbar.add_tool(components.display.DisplayTool(self.board))
        self.toolbar.add_tool(components.button.ButtonTool(self.board))
        self.clickables.append(self.toolbar)
        
        infotext = text.render('FlowSID v0.0.1')
        info = pygame.sprite.Sprite()
        info.image = pygame.Surface(infotext.rect.inflate(3, 3).size)
        info.rect = info.image.get_rect()
        info.image.fill(palette.color(0x10))
        pygame.draw.rect(info.image, palette.color(0x20), info.rect, 1)
        infotext.rect.move_ip(2, 2)
        info.image.blit(infotext.image, infotext.rect)
        colors = tuple(palette.color(x) for x in (0x10,0x20,0x30,0x20))
        def update_info(frame):
            info.rect.bottomright = graphics.screen.get_size()
            for x in range(info.rect.width - 2):
                color = colors[(x - 16*len(colors)*frame/255)/2%len(colors)]
                info.image.fill(color, pygame.Rect(x + 1, 1, 1, 1))