Python graphics.Graphics類代碼示例

 def timer(self):
     print "Time: ", self.time
     print '==============\n'
     g = Graphics(config.MAP)
     g.print_grid()
     sleep(config.SLEEP_TIME)
     self.time += 1

def loop():
	g = Graphics()
	last_paint = 0

	pygame.key.set_repeat(500, 100)

	model = type('Model', (object,), {})
	model.exit = False
	model.new_scene = 'main_menu'
	model.wait = False	

	t = time.time()
	while not model.exit:
		
		while model.new_scene != None:
			next_scene = model.new_scene
			model.new_scene = None
			clazz = scenes[next_scene]
			#give the scene a handle to the mixer
			scene = clazz(model)

		events = pygame.event.get()
		keymap = {}
		for event in events:
			if event.type == pygame.KEYDOWN:
				if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
					return
			
		scene.update(events, time_passed = time.time() - t)
		t = time.time()

		if time.time() - last_paint > 1/30.0 or model.wait:
			#print 'fps: ', 1.0/(time.time() - last_paint)
			last_paint = time.time()
			g.paint(scene, model)

def due_picture():
    data_list = db.run_query("due.sql")
    new_list = DueDate.time_converter(data_list)
    return_list = DueDate.make_dict(new_list)

    Graphics.setup(mode="RGBA", size=(1024, 1024), color=(255, 255, 255, 200))
    Graphics.make_image(return_list, "due.png")

  def __init__(self, asset_path, fps, loc):
      """
        asset_path: the full path to the directory containing the art assets for this animation
      """
      model = [ (0,0), (0,100), (100,100), (100,0) ]
      super(AnimatedActor,self).__init__( model )
      gfx = Graphics()
      self._textures = list()
      image_names = os.listdir(asset_path)
      image_names.sort()
      for each in image_names:  
        path = os.path.join( asset_path, each ) #use path.join to insure cross platform
        self._textures.append( gfx.texture_register(path) )#register the texture with the graphics

        #we need to scale, and the scale factor needs to come from somewhere
#      for i,v in enumerate(self.images):
#        self.images[i] = pygame.transform.scale(v,( v.get_height()/3, v.get_width()/3    ))


      # Track the time we started, and the time between updates.
      # Then we can figure out when we have to switch the image.
      self._start = pygame.time.get_ticks()
      self._delay = 1000 / fps
      self._last_update = 0
      self._frame = 0

        # Call update to set our first image.
      self.update(pygame.time.get_ticks())
      self.loc = loc

      self.alive = True
      self.repeat = False

    def __init__(self, game= 0, playersave= 0):
        self.type  = "player"
        self.game = game
#        self.chunkno = 0
#        self.spawn = (240,260)    #spawn coordinates
        self.velx, self.vely, self.kbvelx, self.kbvely = 0, 0, 0, 0
        self.size = (24,48)        #size of the player sprite, used for hitbox logic etc. This cannot be changed without changing the logic in the hitbox functions!
        self.screensize = (32,48)

        self.upperbody = Graphics.loadplayerimages()[0]
        self.lowerbody = Graphics.loadplayerimages()[1]
        self.playervarsa()
        if not playersave:
            self.playervarsb_make()
            self.spawn = False
        else:
            self.playervarsb_load(playersave)
        
        #playerstatus variables
        self.walking, self.working, self.jumping, self.falling, self.knockedback = False, False, False, False, False
        self.walksound, self.worksound = False, False
        self.rect = pygame.Rect((0, 0), (40, 48))
        self.attrect = pygame.Rect((-100, -100), self.size)
        self.walkanimation = False
        self.workanimation = True
        self.dir = 0

class Display(object):
    """
    The display manager owns the pygame screen object, and the translation
    between world coordinates and screen coordinates. It also dispatches to the
    Graphics class to draw various kinds of objects.

    Architecturally, the display manager looks at the environment, and shows it
    as it chooses, rather than having the environment tell the display manager
    how to show its various pieces.
    """
    def __init__(self, environment, screen_size):
        self.environment = environment
        self.screen_size = screen_size
        self.pixels_per_unit = 15 # TEMP, hardcoded zoom level.
        flags = pg.HWSURFACE | pg.DOUBLEBUF
        if FULLSCREEN:
            flags |= pg.FULLSCREEN
        self.screen = pg.display.set_mode(tuple(self.screen_size), flags)

        self.screen_origin = vec.div(self.screen_size, 2)

        self.widgets = []

        if SHOW_JOYSTICK:
            for i, inp in enumerate(self.environment.inputs):
                self.widgets.append(JoystickWidget(self, inp, i))
        if SHOW_INFO:
            self.fps = 0.0
            self.widgets.append(InfoWidget(self))

        self.widgets.append(HealthWidget(self, self.environment.players))

        self.graphics = Graphics(self)

    def draw(self):
        self.screen.fill(BG_COLOR)

        for o in self.environment.objects:
            self.graphics.draw(o)
        for widget in self.widgets:
            widget.draw(self.screen)

        pg.display.flip()

    def to_screen(self, pos):
        """Convert pos to screen coordinates.

        Takes a tuple a world position, and returns a tuple for the
        screen position.
        """
        x, y = vec.add(
            self.screen_origin,
            vec.mul(pos, self.pixels_per_unit),
        )
        return (int(x), int(y))

    def set_fps(self, fps):
        self.fps = fps

    def renderhud(inventory, inventoryqty, inventoryselected, inventoryopen, windowsize, fps, playerhealth):    #Creates the heads up display surface
        '''Creates and returns HUD'''
        #in: list of 40xint, int 0-9 , bool, tuple of 2 int
        #out: Surface object
        invsurf = pygame.Surface(windowsize, pygame.SRCALPHA, 32)
        text = pygame.font.Font(None, 15).render("FPS:" + str(fps)[0:4], 1, (84, 101, 112))
        invsurf.blit(text, (20,10)) 
        
        slotsize = (40,40)
        slotcolor = (42,42,160)
        slotnumcolor = (220, 220, 220)
        slotnumcolorselected = (40, 200, 40)
        slotnumsize = 16
        slotalpha = 180
        slotoffset = (8,8)
        slotoffset0 = (20, 20)
        
        #inventory
        if not inventoryopen:
            for slot in range(10):
                    slotimg = pygame.Surface(slotsize)
                    slotimg.fill(slotcolor)
#                    if inventory[slot] < 256:
                    slotimg.blit(Graphics.toolimg(inventory[slot]), (0,0))
                    slotimg.set_alpha(slotalpha)
                    slotimg.blit(pygame.font.Font(None, slotnumsize).render(str((slot +1)if slot < 9 else 0), 1, slotnumcolor if not slot == inventoryselected else slotnumcolorselected), (2,2))
                    slotimg.blit(pygame.font.Font(None, slotnumsize).render(str(inventoryqty[slot]), 1, slotnumcolor if not slot == inventoryselected else slotnumcolorselected), (2,28))
                    invsurf.blit(slotimg, (slot * (slotsize[0] + slotoffset[0]) + slotoffset0[0], slotoffset0[1]))

        elif inventoryopen:
            for row in range(4):
                for slot in range(10):
                    slotimg = pygame.Surface(slotsize)
                    slotimg.fill(slotcolor)
                    slotimg.blit(Graphics.toolimg(inventory[slot + 10*row]), (0,0))
                    slotimg.set_alpha(slotalpha)
                    if row ==0:
                        slotimg.blit(pygame.font.Font(None, slotnumsize).render(str(slot +1), 1, slotnumcolor if not slot == inventoryselected else slotnumcolorselected), (2,2))
                    slotimg.blit(pygame.font.Font(None, slotnumsize).render(str(inventoryqty[slot +10*row]), 1, slotnumcolor if not slot == inventoryselected else slotnumcolorselected), (2,28))
                    invsurf.blit(slotimg, (slot * (slotsize[0] + slotoffset[0]) + slotoffset0[0], row * (slotsize[1] + slotoffset[1]) + slotoffset0[1]))
        
        #health hearts
        for i in range(playerhealth[1] / 20):
            if playerhealth[0] / 20:
                playerhealth[0] -=20
                invsurf.blit(Graphics.hearts[0], (windowsize[0] - 46, 20 + 32 *i))
            elif playerhealth[0] / 10:
                playerhealth[0] -=10
                invsurf.blit(Graphics.hearts[1], (windowsize[0] - 46, 20 + 32 *i))
            else:
                invsurf.blit(Graphics.hearts[2], (windowsize[0] - 46, 20 + 32 *i))
                
        return invsurf

    def get_graphics(self):
        url = os.path.join(self._task_master.get_bundle_path(), 'html-content',
                           self._uri)

        graphics = Graphics()
        webkit = graphics.add_uri('file://' + url, height=self._height)
        graphics.set_zoom_level(self._zoom_level)

        self._task_master.activity.set_copy_widget(webkit=webkit)
        self._task_master.activity.set_paste_widget()

        return graphics, self._prompt

    def game_loop(self):
        clock = pygame.time.Clock()

        #Initialize
        self.scoreboard = Scoreboard()
        self.timer = CountDown()
        self.control = Control()
        self.graphics = Graphics(self.scoreboard, self.timer);
        self.player = Player(self.graphics)
        self.world = World(self.graphics, self.player) 
        self.logic = Logic(self.player, self.world, self.graphics, self.scoreboard, self.timer, self.control)
        
        while globalvars.run_game:
            delta = clock.tick(30) # fps

            # Catch input event
            for event in pygame.event.get():
                if event.type == QUIT:
                    return
                else:
                    self.control.update(event)
                
            # Update 
            self.logic.update(delta)
            self.world.update(delta)
            self.graphics.update(self.screen, delta)
            
            # Render
            self.graphics.draw(self.screen, delta);
            self.screen.blit(self.player.speedmsg, (0, 35))
            self.screen.blit(self.player.rotmsg, (0, 55))            
              
            pygame.display.flip()        

    def __init__(self):
        ''' Initialize starting state'''
        self.graphics = Graphics()
        self.log = logging.getLogger("Game");
        logging.basicConfig(filename='main.log', level=DEBUG_LEVEL)
        self.log_handler = CursesHandler(self.graphics.windows["log"])
        self.log_handler.setLevel(DEBUG_LEVEL)
        self.log.addHandler(self.log_handler)
        self.commands = Commands(self)
        self.cursor_pos = [0,0]
        self.game_mode = GameModes.normal
        self.world = World(log_handler=self.log_handler)

        try:
            # Try to load a level from a text file and add it to the world
            # self.world.add_level(self.world.read_level('../data/testworld'))
            # self.world.get_current_level().add_entity(entity.creatures.SpaceOrk(5,5))
            self.world.add_level(
                    self.world.generate_level(
                        self.graphics.max_x, self.graphics.world_height))

            #Place player at spawn
            self.player = entity.creatures.Player(1,1)
            for ent in self.world.get_current_level().entities:
                if ent.__class__ == entity.world.PlayerSpawn:
                    self.player = entity.creatures.Player(ent.position[0],ent.position[1])

            self.world.get_current_level().add_entity(self.player)
        except Exception:
            # use better exception
            self.exit(1)

        self.log.debug("Game started")

 def __init__(self, scripts, useGraphics = False, synchronizeGraphics = False, maximumRounds = DEFAULT_MAXIMUM_ROUNDS, decay = 1, minimumRounds = 0):
     '''
     Constructor for Game class.
     
     @param scripts: A dict of robotBehavior objects keyed to the script's name.
     @param useGraphics: The Graphics object being used to render the graphics object. If graphics is None, no graphical display will be done.
     @param synchronizeGraphics: If graphics are being used, making this True will cause the game loop to update at the same rate as the graphics loop,
     rather than running as fast as it can. This is available for debugging purposes.
     @param maximumRounds: The maximum number of rounds in the game.
     @param decay: The decay rate of the game, i.e. the probability that the next round will take place.
     @param minimumRounds: The minimum number of rounds in the game.
     '''
     
     # ====================
     # INITIALIZE VARIABLES
     # ====================
     
     # initialize passed in variables
     self.maximumRounds = maximumRounds
     self.decay = decay
     self.minimumRounds = minimumRounds
     self.scripts = scripts
     
     # if graphics are being used, initialize graphics
     if useGraphics: 
         self.graphics = Graphics()
         self.synchronizeGraphics = synchronizeGraphics

    def updateblockgraphix(self, blx, bly):     #updates graphics when a block changes
        self.newtex = Graphics.blocktexture((self.blocks[blx][bly] & 65280) >>8)[(self.blocks[blx][bly] & 240) >> 4]
#        self.surface.blit(self.newtex if not self.blocks[blx][bly] & 0b11110000 == 0b11110000 else pygame.transform.flip(self.newtex, np.random.randint(0, 1), np.random.randint(0, 1)), (blx * 16, bly * 16))
#        self.surface.blit(pygame.transform.flip(self.newtex, np.random.randint(0, 2), np.random.randint(0, 2)) if self.blocks[blx][bly] & 0b11110000 == 0b11110000 else self.newtex, (blx * 16, bly * 16))          #flips
        self.surface.blit(pygame.transform.flip(pygame.transform.rotate(self.newtex, np.random.randint(0, 4) *90), np.random.randint(0, 2), np.random.randint(0, 2))  if self.blocks[blx][bly] & 0b11110000 == 0b11110000 else self.newtex, (blx * 16, bly * 16))          #flips
        if settings.game["debugmode"]:        
            pygame.draw.line(self.surface, Color.red, (0,0), (0,1024))
            pygame.draw.line(self.surface, Color.red, (0,0), (1024,0))

class Actor( object ):
  """
    Base Class for Actors. Actors are any objects with an onscreen representation.

    Actor class contains:
     model    : wireframe model representing the onscreen actor
     rectangle: bounding rectangle, projection of model on to the plane, used for intersection 
                and collision detection            
     texture  : image to texture the model
  """
  def __init__( self, model, texture=None, drawmode='polygon', offset=(0,0) ):
    """
      Initialize the actor
      INPUT:
            - model: unknown representation of this Actor's model, dependent on graphics system
            - texture: unknow representation of the texture to apply to this Actor's model
            - bounding_rect: rectangular projection of this actor's model onto the plane, used
                             for intersection and collision
            - gfx_sys: graphics system reference TODO: get rid of this
    """
    self._model = model #TODO assume array
    #self._boundrect = bounding_rect #TODO assume array
    self._texpath = texture #TODO assume path
    self._mode = drawmode
    self._gfxsys = Graphics()
    self._offset = offset
    if texture: 
      self._texid = self._gfxsys.texture_register( self._texpath )
    else:
      self._texid = None
    self._position = (0,0)
#=================================================================================================
  def draw( self, pos, name ):
    """
      Request that this object be drawn at pos
    """
    self._position = (pos[0]+self._offset[0],pos[1]+self._offset[1])
    #print self._position
    self._gfxsys.blit( self._model, self._position, name, self._texid, self._mode )
#=================================================================================================
  def updatepos( self, pos ):
    """
      update this actor's position outside of a draw call
    """
    self._position = pos

 def _load_intro_graphics(self, file_name='generic-problem.html',
                          message=None):
     center_in_panel = Gtk.Alignment.new(0.5, 0, 0, 0)
     url = os.path.join(self.bundle_path, 'html-content', file_name)
     graphics = Graphics()
     if message is None:
         graphics.add_uri('file://' + url)
     else:
         graphics.add_uri('file://' + url + '?MSG=' +
                          utils.get_safe_text(message))
     graphics.set_zoom_level(0.667)
     center_in_panel.add(graphics)
     graphics.show()
     self.set_canvas(center_in_panel)
     center_in_panel.show()

def main():
	# Parse arguments
	argparser = argparse.ArgumentParser()
	argparser.add_argument('-g', '--graphics', action="store_true")
	flags = argparser.parse_args()

	# Let there be light! (create an N-particle universe)
	universe = Universe(N_PARTICLES)
	print universe
	
	# Create graphics 
	if flags.graphics and graphics_imported:
		graph = Graphics(universe, GRAPHICS_DIR)
		graph.save_plot()
	
	# Incremenent time
	for i in xrange(50):
		print 'Computing step', i+1
		universe.increment_time()
		if flags.graphics and graphics_imported:
			graph.save_plot()