def __init__(self, engine): """ The game determines what is happening on screen based on what state the GameEngine instance has. """ # the game engine that owns this state self.engine = engine # TRYING TO DEPRECATE self.screen = Screen() self.res = self.engine.setsMgr.screenRes res = self.res # get/load the font self.font = FontManager().loadFont( 'JohnDoe' ) self.str_paused = UIText( "Paused", [res[0]*0.5, res[1]*0.5] , self.font, 35 ) self.str_paused.setVisible(False) gameWorld = self.engine.gameWorld #gameWorld.setPlayerType( 'Cop' ) gameWorld.setPlayerType( 'Robber' ) #gameWorld.getPlayer().setName( "Alfonso" ) # This is an optimization... # If using the Cop player type, use the smaller tiles if gameWorld.getPlayer().getType() == "Cop": gameWorld.setLevelByName( 'Level1XS' ) else: gameWorld.setLevelByName( 'Level1L' ) glutTimerFunc(50, self.engine.on_update, 50)
def __init__(self, engine): """ The game determines what is happening on screen based on what state the GameEngine instance has. """ self.engine = engine self.screen = Screen() self.res = self.engine.setsMgr.screenRes res = self.res # saying 'self.res' was making lines too long. :P # get/load the font self.font = FontManager().loadFont( 'Basic' ) # screen objects self.UI = {} self.UI['title'] = UIText("Breakin And Poppin"\ , pos=[res[0]*.01,res[1]*.10], font=self.font, scale=0.05) self.UI['start_server'] = UIText("Start a Server"\ , pos=[res[0]*0.5, res[1]*0.42], font=self.font, scale=0.04) self.UI['start_server'].center() self.UI['join_server'] = UIText("Join a Server"\ , pos=[res[0]*0.5, res[1]*0.5], font=self.font, scale=0.04) self.UI['join_server'].center() self.UI['quit'] = UIText("Quit"\ , pos=[res[0]*0.5, res[1]*0.58], font=self.font, scale=0.04) self.UI['quit'].center() self.titleBGImg = UIImage("TitleScreenBG.png"\ , pos=[0,0], size=res) self.selected = 'start_server'
def Main(): """Runs once the user has entered the application.""" pygame = SystemState.pygame while SystemState.application == 'camera': Events.CheckEvents() if SystemState.screen_mode in (1, 2, 5, 6): SystemState.CameraState.camera_stream = True else: SystemState.CameraState.camera_stream = False if SystemState.CameraState.camera_stream == True: # Button on RPi.GPIO 8 if not RPi.GPIO.input(8): CallTakePhoto() SystemState.CameraState.stream = io.BytesIO() # Capture into in-memory stream SystemState.camera.capture(SystemState.CameraState.stream, use_video_port=True, splitter_port=0, format='rgb') SystemState.CameraState.stream.seek(0) SystemState.CameraState.stream.readinto(SystemState.rgb) # stream -> YUV buffer SystemState.CameraState.stream.close() SystemState.img = SystemState.pygame.image.frombuffer(SystemState.rgb[0: (320 * 240 * 3)], (320, 240), 'RGB' ) xa = (320 - SystemState.img.get_width() ) / 2 ya = (240 - SystemState.img.get_height()) / 2 Screen.RefreshScreen(image=SystemState.img, wx=xa, wy=ya)
def renderFrame(self): """ RenderFrame - Base Class """ if not self.screen: self.screen = Screen() self.screen.drawThis( self.str_paused ) return self
def scrollScreen(self): dir = self.player.facingDir #playerPos = list(self.player.getCenterPos()) playerPos = list(self.player.pos) if not self.screen: self.screen = Screen() screenRes = self.screen.size # the extent from the side-buffer(above) scrExtent = ( self.scrScroll[0] + screenRes[0] , self.scrScroll[1] + screenRes[1] ) # The current screen scroll + the side buffer offset # and the size # The order of the "walls" indicated within are # West, North, East, South scrEdge = ( self.scrScroll[0] + self.sideBuf[0] , self.scrScroll[1] + self.sideBuf[1] , scrExtent[0] - self.sideBuf[0] , scrExtent[1] - self.sideBuf[1] ) # the screen movement based on its current position offset = [0,0] # Horizontal, player is within the area if playerPos[0] > scrEdge[0] and dir[0] > 0: if abs(playerPos[0] - scrEdge[0]) >= self.scrSpeed[0]: offset[0] = self.scrSpeed[0] else: offset[0] = int(playerPos[0] - scrEdge[0]) if playerPos[0] < scrEdge[2] and dir[0] < 0: if abs(playerPos[0] - scrEdge[2]) >= self.scrSpeed[0]: offset[0] = -self.scrSpeed[0] else: # ..subtracted in this order, (pos - scrEdge) is already negative.. offset[0] = int(playerPos[0] - scrEdge[2]) # Vertical if playerPos[1] > scrEdge[1] and dir[1] > 0: if abs(playerPos[1] - scrEdge[1]) >= self.scrSpeed[1]: offset[1] = self.scrSpeed[1] else: offset[1] = int(playerPos[1] - scrEdge[1]) if playerPos[1] < scrEdge[3] and dir[1] < 0: if abs(playerPos[1] - scrEdge[3]) >= self.scrSpeed[1]: offset[1] = -self.scrSpeed[1] else: offset[1] = int(playerPos[1] - scrEdge[3]) # move the screen by the ofset self.moveScreen( offset )
def renderFrame(self): """ RenderFrame - Base Class """ if not self.screen: self.screen = Screen() scrSize = self.screen.getSize() #self.engine.gameWorld.positionPlayer( [scrSize[0],scrSize[1]] ) self.screen.drawThis( self.str_paused ) return self
def Main(): """Main loop for the camera application.""" pygame = SystemState.pygame SystemState.camera.resolution = (320, 240) while SystemState.application == 'video': # Check for button presses, messages, and which mode we're in. Events.CheckEvents() if SystemState.screen_mode in (1, 2, 3): SystemState.VideoState.video_stream = True else: SystemState.VideoState.video_stream = False try: video_message_queue = SystemState.VideoState.video_message_queue.get(None) except Queue.Empty: video_message_queue = None # Checking video message queue for record messages. if video_message_queue != None: recording_state = video_message_queue.get('recording') if recording_state == True: timestamp = str(int(time.time())) __CallRecordAudio(timestamp) __CallRecordVideo(timestamp) SystemState.VideoState.video_recording = True elif recording_state == False: SystemState.VideoState.video_recording = False TextWriter.ClearPermatext() # Checking the gpio button that starts recording. if SystemState.VideoState.video_recording == False: if not RPi.GPIO.input(8) and SystemState.screen_mode == 1: SystemState.VideoState.video_message_queue.put({'recording': True}) Menu.JumpTo(screen_mode=6) TextWriter.Write( text='Rec', position=(10, 10), color=(255,0,0), permatext=True, state=SystemState, size=20 ) # Check if we are in a streaming mode. If so, throw frames at the screen. if SystemState.VideoState.video_stream == True: SystemState.VideoState.stream = io.BytesIO() # Capture into in-memory stream SystemState.camera.capture(SystemState.VideoState.stream, use_video_port=True, splitter_port=0, format='rgb') SystemState.VideoState.stream.seek(0) SystemState.VideoState.stream.readinto(SystemState.rgb) SystemState.VideoState.stream.close() SystemState.VideoState.img = SystemState.pygame.image.frombuffer(SystemState.rgb[0: (320 * 240 * 3)], (320, 240), 'RGB' ) xa = (320 - SystemState.VideoState.img.get_width() ) / 2 ya = (240 - SystemState.VideoState.img.get_height()) / 2 Screen.RefreshScreen(image=SystemState.VideoState.img, wx=xa, wy=ya)
def renderFrame(self): if not self.screen: self.screen = Screen() self.screen.drawThis( self.titleBGImg ) selectionBox = UIImage("box.png", pos=self.UI[self.selected].pos, size=[(self.res[0]*0.05)*10, self.res[1]*0.05]) selectionBox.center() self.screen.drawThis( selectionBox ) for uiObj in self.UI.values(): # draw the background image firstly self.screen.drawThis( uiObj ) return self
def renderFrame(self): """ RenderFrame - Base Class """ if not self.screen: self.screen = Screen() self.screen.drawThis( self.titleBGImg ) self.screen.drawThis( self.UI['nice_work'] ) if self.engine.gameWorld.getPlayerType() == "Robber": self.screen.drawThis( self.UI['robber_wins'] ) elif self.engine.gameWorld.getPlayerType() == "Cop": self.screen.drawThis( self.UI['cop_wins'] ) self.screen.drawThis( self.UI['press_esc'] ) return self
def moveScreen( self, offset=[0,0] ): """ Moves the screen in world coords offset from its current position. """ if not self.screen: self.screen = Screen() # validate the upper and left extent self.scrScroll[0] = max( self.scrScroll[0]+offset[0], 0 ) self.scrScroll[1] = max( self.scrScroll[1]+offset[1], 0 ) tileSize = self.level.tileScrSize scrSize = self.screen.size mapSize = self.level.mapSize self.scrScroll[0] = min( self.scrScroll[0] , (mapSize[0]*tileSize[0]) - scrSize[0] ) self.scrScroll[1] = min( self.scrScroll[1] , (mapSize[1]*tileSize[1]) - scrSize[1] )
def __init__(self): """ Initializes the game client """ # since our game client is a client... Client.__init__(self) self.setsMgr = SettingsManager() self.res = self.setsMgr.screenRes self._InitGLUT_() self._InitGL_() # Make a screen object - we want to make the first here # so that we can ensure the size is set appropriately. # All other objects using the screen-singleton will assume # it is has already been sized and, thus, won't call setSize. self.screen = Screen() self.screen.setSize( self.res ) # be the first entity to create the managers self.rsrcMgr = TextureManager() self.fontMgr = FontManager() self.connected = False self.serverOwner = False self.serverName = "default" # the gameworld is mostly undefined at this point self.gameWorld = GameWorld() # this variable denotes for certain game states whether # the user 'start'-ed or 'join'-ed a server so they know # which state to return to when the user pushes 'back' self.statePath = None # create the initial game state self.gState = TitleScreenState(self)
def __init__(self): """ Init: (self) """ # grab the settings manager cause we need it here self.setsMgr = SettingsManager() # all things in the world scene (except the level and the player) self.objects = [] self.collisions = {} self.prevCols = {} # store this separately so we know where it is self.levelName = "" self.level = PreBuiltLevel() # the user's player object self.player = None # the peer players on other computers in the network self.peers = {} # the player's controller (set to settings-default) self.controller = None self.setControllerType( self.setsMgr.controller ) # the screen object self.screen = Screen() # the screen's position in world space self.scrScroll = [0,0] self.scrSize = self.screen.getSize() scrMiddle = (self.scrSize[0]/2, self.scrSize[1]/2) #self.sideBuf = ( self.scrSize[0]*0.4, self.scrSize[1]*0.4 ) self.sideBuf = ( 100, 100 ) # the max deviation that the player self.maxDevi = ( self.scrSize[0]/2 - self.sideBuf[0] , self.scrSize[1]/2 - self.sideBuf[1] ) self.scrSpeed = (0,0) self.status = "undecided" self.active = False # This is the 'pause' flag. self.gameTime = 0.0 self.gameStatus = 'unresolved' # Denotes whether the Robber has touched the drop point self.drop_point_hit = False # for the 'Robber' only # A few messages for indicating to the user # get/load the font self.font = FontManager().loadFont( 'Basic' ) # a text objects for der screenzimmer self.txtObjs = [] # this will make rendering easy self.cops_got_ya = UIText("The Cops got ya!!", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.cops_got_ya ) self.robber_detained = UIText("The Robber has been detained.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.robber_detained ) self.lose_the_cops = UIText("Ya gotta lose the cops first!", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.lose_the_cops ) self.go_to_base = UIText("Ya already dropped off the loot.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.go_to_base ) self.go_to_drop = UIText("Go to the Drop Point first.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.go_to_drop ) self.safe_at_base = UIText("Ya made it! Great job.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.safe_at_base ) self.dropped_loot = UIText("Good, now head to the Base", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.dropped_loot ) self.robber_eluded = UIText("The robber eluded us.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.robber_eluded ) for txtObj in self.txtObjs: txtObj.setVisible( False ) txtObj.center()
class GameWorld(): """ A class to encapsulate all objects in the world-space of the 'game'. """ def __init__(self): """ Init: (self) """ # grab the settings manager cause we need it here self.setsMgr = SettingsManager() # all things in the world scene (except the level and the player) self.objects = [] self.collisions = {} self.prevCols = {} # store this separately so we know where it is self.levelName = "" self.level = PreBuiltLevel() # the user's player object self.player = None # the peer players on other computers in the network self.peers = {} # the player's controller (set to settings-default) self.controller = None self.setControllerType( self.setsMgr.controller ) # the screen object self.screen = Screen() # the screen's position in world space self.scrScroll = [0,0] self.scrSize = self.screen.getSize() scrMiddle = (self.scrSize[0]/2, self.scrSize[1]/2) #self.sideBuf = ( self.scrSize[0]*0.4, self.scrSize[1]*0.4 ) self.sideBuf = ( 100, 100 ) # the max deviation that the player self.maxDevi = ( self.scrSize[0]/2 - self.sideBuf[0] , self.scrSize[1]/2 - self.sideBuf[1] ) self.scrSpeed = (0,0) self.status = "undecided" self.active = False # This is the 'pause' flag. self.gameTime = 0.0 self.gameStatus = 'unresolved' # Denotes whether the Robber has touched the drop point self.drop_point_hit = False # for the 'Robber' only # A few messages for indicating to the user # get/load the font self.font = FontManager().loadFont( 'Basic' ) # a text objects for der screenzimmer self.txtObjs = [] # this will make rendering easy self.cops_got_ya = UIText("The Cops got ya!!", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.cops_got_ya ) self.robber_detained = UIText("The Robber has been detained.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.robber_detained ) self.lose_the_cops = UIText("Ya gotta lose the cops first!", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.lose_the_cops ) self.go_to_base = UIText("Ya already dropped off the loot.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.go_to_base ) self.go_to_drop = UIText("Go to the Drop Point first.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.go_to_drop ) self.safe_at_base = UIText("Ya made it! Great job.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.safe_at_base ) self.dropped_loot = UIText("Good, now head to the Base", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.dropped_loot ) self.robber_eluded = UIText("The robber eluded us.", pos=scrMiddle, font=self.font, scale=0.025) self.txtObjs.append( self.robber_eluded ) for txtObj in self.txtObjs: txtObj.setVisible( False ) txtObj.center() #\\\\\\\\\\\\\\\\\\\\\\\\\\# # World control def pause(self): """ Pause/Unpause the gameworld """ if self.active == True: self.active = False else: self.active = True return self.active def startGame(self): """ Explicitly sets a game to active """ self.active = True def stopGame(self): """ Explicitly stops the game """ self.active = False def on_socket( self, packet ): """ receives the 'update' packet and reads it """ #process the packet try: for plData in packet['players']: self.updatePeer( plData ) except KeyError: print "GameWorld -` on_socket - Missing 'players' in update packet" pass def update( self, elapsed ): """ Call the update function of all objects in the gameworld. """ # don't update if the gameworld is inactive if not self.active: # either the game is paused or the game hasn't started yet return # update the controller # (as it might be necessary depending on the type) self.controller.update(elapsed) # Update collisions first(to hopefully achieve greater accuracy) for coll in self.collisions.values(): coll.update(elapsed) # send the elapsed time to the player (for whatever it needs to do) if self.player: # update the player animation self.player.update(elapsed) self.ensureWithinLevel() # update the screen pos based on the character # pos and facing direction self.scrollScreen() if self.level: # update the level self.level.update(elapsed) # update the peer avatars for peer in self.peers.values(): peer.update(elapsed) # all world objects for obj in self.objects: obj.update(elapsed) #/\/\/\# Collision #/\/\/\# # copy the old collisions to another list self.prevCols = dict(self.collisions) self.collisions = {} ## Player-to-Level if self.player.getType() == "Robber": tileType, offset = self.level.getTileAtPoint(self.player.pos) if not tileType: pass elif tileType == 'base': self.addCollision(Collision.ROBBER, Collision.BASE) elif tileType == 'building': posAdjust = [0,0] if offset[0] < self.level.tileHalfSize[0]: posAdjust[0] = offset[0] * -1 elif offset[0] >= self.level.tileHalfSize[0]: posAdjust[0] = (self.level.tileScrSize[0]-offset[0]) if offset[1] < self.level.tileHalfSize[1]: posAdjust[1] = offset[1] * -1 elif offset[1] >= self.level.tileHalfSize[1]: posAdjust[1] = (self.level.tileScrSize[1]-offset[1]) self.player.pos[0] += posAdjust[0] self.player.pos[1] += posAdjust[1] elif tileType == 'drop-point': self.addCollision(Collision.ROBBER, Collision.DROP_POINT) for peer in self.peers.values(): # player's of the same type do not collide (for now) if peer.getType() != self.player.getType(): if self.player.getType() == "Cop": # collide the peer(a robber) with the player's spotlight if self.player.collidePoint( peer.pos ): self.addCollision( Collision.ROBBER, Collision.COP ) elif self.player.getType() == "Robber": # collide the peer's spotlight with the player(a robber) if peer.collidePoint( self.player.pos ): self.addCollision( Collision.ROBBER, Collision.COP ) # This is not in use for now # ## Player-to-Objects #for obj in self.objects: # #collide the object box with the robber pos only # if self.player.getType() == "Robber": # print 'object' #/\/\/\# Collision Response #/\/\/\# cop_robber_coll = False try: # First, determine if there is a cop-to-robber collision as # this will be relevant to the effect of other collisions # This collision depends on the player type if self.collisions[(Collision.ROBBER, Collision.COP)].getTime() > 3000: if self.player.getType() == "Robber": #self.cops_got_ya.setPos(\ # ( self.player.pos[0], self.player.pos[1]+10 ) ) self.cops_got_ya.setVisible(True) glutTimerFunc( 2000, self.cops_got_ya.toggleVisible, 0 ) self.gameStatus = "loser" elif self.player.getType() == "Cop": #self.robber_detained.setPos(\ # ( self.player.pos[0], self.player.pos[1]+10 )) self.robber_detained.setVisible(True) glutTimerFunc( 2000, self.robber_detained.toggleVisible, 0 ) self.gameStatus = "winner" self.active = True except KeyError: # the collision is not present (saved myself a few 'if'-stmts, above) pass try: # We can assume the next two can only occur when the player is a "Robber" if (Collision.ROBBER, Collision.DROP_POINT) in self.collisions: if cop_robber_coll == True: #self.lose_the_cops.setPos(\ # (self.player.pos[0], self.player.pos[1]+10) ) self.lose_the_cops.setVisible(True) glutTimerFunc( 2000, self.lose_the_cops.toggleVisible, 0 ) #elif self.drop_point_hit == True: # #self.go_to_base.centerAround( self.player.pos ) # self.go_to_base.setVisible(True) # glutTimerFunc( 2000, self.go_to_base.toggleVisible, 0 ) elif self.collisions[(Collision.ROBBER, Collision.DROP_POINT)].getTime() > 3000: self.drop_point_hit = True #self.dropped_loot.setPos(\ # ( self.player.pos[0], self.player.pos[1]+10 )) self.dropped_loot.setVisible(True) glutTimerFunc( 2000, self.dropped_loot.toggleVisible, 0 ) except KeyError: # the collision is not present (saved myself a few 'if'-stmts, above) pass try: if (Collision.ROBBER, Collision.BASE) in self.collisions: if cop_robber_coll == True: #self.lose_the_cops.setPos(\ # ( self.player.pos[0], self.player.pos[1]+10 )) self.lose_the_cops.setVisible(True) glutTimerFunc( 2000, self.lose_the_cops.toggleVisible, 0 ) elif self.drop_point_hit == False: self.go_to_drop.setVisible(True) glutTimerFunc( 2000, self.go_to_drop.toggleVisible, 0 ) elif self.collisions[(Collision.ROBBER, Collision.BASE)].getTime() > 3000: self.gameStatus = "winner" self.active = False #self.safe_at_base.setPos(\ # ( self.player.pos[0], self.player.pos[1]+10 )) self.safe_at_base.setVisible(True) glutTimerFunc( 2000, self.safe_at_base.toggleVisible, 0 ) except KeyError: # the collision is not present (saved myself a few 'if'-stmts, above) pass def addCollision(self, type1, type2): """ This function determines whether to add a new collision or to transfer an existing one to the new list. """ if (type1, type2) in self.prevCols: self.collisions[(type1, type2)] = self.prevCols[(type1, type2)] else: self.collisions[(type1, type2)] = Collision((type1, type2)) #\\\\\\\\\\\\\\\\\\\\\\\\\\# # Player setup/control def setPlayer( self, player ): """ Set the player by object """ self.player = player #self.player.setName( self.setsMgr.player_name ) if self.controller: self.controller.setPlayer( self.player ) def setPlayerType( self, type ): """ Set the player by type-str """ if type == 'Robber': self.setPlayer( Robber() ) #self.player.setName( self.setsMgr.player_name ) if self.level: self.level.setTilesPerView( [15,15] ) self.player.setPos(self.level.getThiefInitPos()) self.player.scaleSizeByTileSize( self.level.getTileSize() ) elif type == 'Cop': self.setPlayer( Cop() ) #self.player.setName( self.setsMgr.player_name ) if self.level: self.level.setTilesPerView( -1 ) self.player.setPos( self.level.getCopInitPos() ) self.player.scaleSizeByTileSize( self.level.getTileSize() ) else: print type, ' is not an acceptable argument to setPlayer()' if self.controller: self.controller.setPlayer( self.player ) self.scrSpeed = ( int(self.player.moveSpeed[0]), int(self.player.moveSpeed[1]) ) self.centerScreenAroundPlayer() def getPlayer( self ): return self.player def getPlayerType( self ): if self.player: return self.player.getType() else: return None def movePlayer( self, offset=(0,0) ): """ Simply calls the position func of the player """ self.player.move( offset ) def positionPlayer( self, pos=(1,1) ): """ Place the player at some particular spot """ self.player.setPos( pos ) def ensureWithinLevel( self ): """ checks the player's position is within the level area """ mapSize = self.level.mapSize tileSize = self.level.tileScrSize playerPos = self.player.pos # check that PosX > left_edgeTileWidth if playerPos[0] < 0: self.positionPlayer([0, playerPos[1]]) # check that PosY > top_edgeTileHeight if playerPos[1] < 0: self.positionPlayer([playerPos[0], 0]) # check that PosX < right_EdgeTileWidths if playerPos[0] > mapSize[0]*tileSize[0]: self.positionPlayer( [(mapSize[0]*tileSize[0]), playerPos[1]] ) # check that PosY < bottom_EdgeTileWidth if playerPos[1] > mapSize[1]*tileSize[1]: self.positionPlayer( [playerPos[0], (mapSize[1]*tileSize[1])] ) #\\\\\\\\\\\\\\\\\\\\\\\\\\# # Controller Setup def setController( self, controller ): """ Set the controller by passing a derived Controller class """ self.controller = controller self.controller.setPlayer( self.player ) def setControllerType( self, type ): """ Sets the controller by passing either "keyboard" or "mouse" """ # determine which type of controller to create if type.lower() == "keyboard": self.controller = Keyboard() elif type.lower() == "mouse": self.controller = Mouse() else: print "Set Controller Failed with type: ", type return # set the player of the controller self.controller.setPlayer(self.player) def getController( self ): return self.controller def centerScreenAroundPlayer(self): """ As the name suggests, it centers the screen as best it can around the player. """ self.positionScreen( [self.player.pos[0]-(self.scrSize[0]/2), self.player.pos[1]-(self.scrSize[1]/2) ] ) # this will check the screen to make sure it is within the bounds # of the level self.moveScreen( [0,0] ) #\\\\\\\\\\\\\\\\\\\\\\\\\\# # Level setup def setLevelByName( self, level=None ): """ Set the level by name """ if level: self.levelName = level self.level.load( level ) if self.player: if self.player.type == 'Robber': self.level.setTilesPerView( [15,15] ) self.player.setPos( self.level.getThiefInitPos() ) self.player.scaleSizeByTileSize( self.level.getTileSize() ) elif self.player.type == 'Cop': self.level.setTilesPerView( -1 ) self.player.setPos( self.level.getCopInitPos() ) self.player.scaleSizeByTileSize( self.level.getTileSize() ) self.centerScreenAroundPlayer() else: self.level = None def setLevel( self, level=None ): """ Set the level with an instance """ self.level = level if self.player and self.level: self.levelName = self.level.lvlName if self.player.type == 'Robber': self.level.setTilesPerView( [15,15] ) self.player.setPos( self.level.getThiefInitPos() ) self.player.scaleSizeByTileSize( self.level.getTileSize() ) elif self.player.type == 'Cop': self.level.setTilesPerView( -1 ) self.player.setPos( self.level.getCopInitPos() ) self.player.scaleSizeByTileSize( self.level.getTileSize() ) self.centerScreenAroundPlayer() def getLevel( self ): return self.level def getLevelName( self ): return self.level.lvlName #\\\\\\\\\\\\\\\\\\\\\\\\\\# # Drawing def render( self ): """ Called by the screen class; this function will call render() of all entities in self.objects and return the compiled list """ renderList = [] # don't update if paused if not self.active: return renderList # render order is relevant in this function esp. wrt the level and # the player. if self.level: if self.player.type == 'Robber': renderList.extend(self.level.render(self.scrScroll)) elif self.player.type == 'Cop': quad = self.player.getQuad( self.scrScroll ) renderList.extend(self.level.render(self.scrScroll, quad)) if self.player: renderList.extend( self.player.render(self.scrScroll) ) for object in self.objects: renderList.extend( object.render(self.scrScroll) ) for peer in self.peers.values(): if self.player.type == "Cop": quad = self.player.getAreaUnder( self.scrScroll ) if peer.pos[0] > quad[0] and peer.pos[0] < quad[2] \ and peer.pos[1] > quad[1] and peer.pos[1] < quad[3]: renderList.extend( peer.render(self.scrScroll) ) else: renderList.extend( peer.render(self.scrScroll) ) for txt in self.txtObjs: #renderList.extend( txt.render(self.scrScroll) ) renderList.extend( txt.render() ) return renderList #\\\\\\\\\\\\\\\\\\\\\\\\\\# # Screen control def moveScreen( self, offset=[0,0] ): """ Moves the screen in world coords offset from its current position. """ if not self.screen: self.screen = Screen() # validate the upper and left extent self.scrScroll[0] = max( self.scrScroll[0]+offset[0], 0 ) self.scrScroll[1] = max( self.scrScroll[1]+offset[1], 0 ) tileSize = self.level.tileScrSize scrSize = self.screen.size mapSize = self.level.mapSize self.scrScroll[0] = min( self.scrScroll[0] , (mapSize[0]*tileSize[0]) - scrSize[0] ) self.scrScroll[1] = min( self.scrScroll[1] , (mapSize[1]*tileSize[1]) - scrSize[1] ) def positionScreen( self, pos=[0,0] ): """ Put the screen at a specific position """ self.scrScroll[0] = pos[0] self.scrScroll[1] = pos[1] def scrollScreen(self): dir = self.player.facingDir #playerPos = list(self.player.getCenterPos()) playerPos = list(self.player.pos) if not self.screen: self.screen = Screen() screenRes = self.screen.size # the extent from the side-buffer(above) scrExtent = ( self.scrScroll[0] + screenRes[0] , self.scrScroll[1] + screenRes[1] ) # The current screen scroll + the side buffer offset # and the size # The order of the "walls" indicated within are # West, North, East, South scrEdge = ( self.scrScroll[0] + self.sideBuf[0] , self.scrScroll[1] + self.sideBuf[1] , scrExtent[0] - self.sideBuf[0] , scrExtent[1] - self.sideBuf[1] ) # the screen movement based on its current position offset = [0,0] # Horizontal, player is within the area if playerPos[0] > scrEdge[0] and dir[0] > 0: if abs(playerPos[0] - scrEdge[0]) >= self.scrSpeed[0]: offset[0] = self.scrSpeed[0] else: offset[0] = int(playerPos[0] - scrEdge[0]) if playerPos[0] < scrEdge[2] and dir[0] < 0: if abs(playerPos[0] - scrEdge[2]) >= self.scrSpeed[0]: offset[0] = -self.scrSpeed[0] else: # ..subtracted in this order, (pos - scrEdge) is already negative.. offset[0] = int(playerPos[0] - scrEdge[2]) # Vertical if playerPos[1] > scrEdge[1] and dir[1] > 0: if abs(playerPos[1] - scrEdge[1]) >= self.scrSpeed[1]: offset[1] = self.scrSpeed[1] else: offset[1] = int(playerPos[1] - scrEdge[1]) if playerPos[1] < scrEdge[3] and dir[1] < 0: if abs(playerPos[1] - scrEdge[3]) >= self.scrSpeed[1]: offset[1] = -self.scrSpeed[1] else: offset[1] = int(playerPos[1] - scrEdge[3]) # move the screen by the ofset self.moveScreen( offset ) #\\\\\\\\\\\\\\\\\\\\\\\\\\# # World-object stuff def addObject( self, newObj ): """ Appends an object to the game world(as long as it can be rendered) """ if 'render' in dir( newObj ): self.objects.append( newObj ) else: print 'Warning : GameWorld : newObj does not have a "render" function; it was not added to the render list.' def updatePeer( self, update ): """ update (or add) a peer to the game world """ if update['name'] == self.player.getName(): # ignore this packet because it is the player packet return if update['name'] not in self.peers: # Make a player object of the type in the packet if update['pType'] == 'Robber': newPlayer = Robber() newPlayer.setPos( self.scalePos(update['position']) ) newPlayer.setSize( self.getPeerSize( "Robber") ) self.peers[ update['name'] ] = newPlayer if update['pType'] == 'Cop': newPlayer = Cop() newPlayer.setPos( self.scalePos(update['position']) ) newPlayer.setSize( self.getPeerSize( "Cop") ) self.peers[ update['name'] ] = newPlayer else: self.peers[ update['name'] ].setPos(\ self.scalePos(update['position'])) def scalePos(self, pos): """ scales the peer's map pos to tile coords """ tileSize = self.level.getTileSize() return [ pos[0]*tileSize[0], pos[1]*tileSize[1] ] def getPeerSize(self, type): """ Calculates and returns the size of a peer based on its type and the playyer's type. """ size = None tileSize = self.level.getTileSize() if self.player.type == type: pass elif self.player.type == "Robber": # then peer-type == "Cop" size = [tileSize[0]*5, tileSize[1]*5] elif self.player.type == "Cop": # then peer-type == "Robber" size = [tileSize[0]*0.5, tileSize[1]*0.5] return size def on_key_press(self, key, x, y): """On key press""" if self.active: if self.controller and isinstance( self.controller, Keyboard ): self.controller.on_key_press(key, x, y) def on_key_release(self, key, x, y): """On key release""" if self.active: if self.controller and isinstance( self.controller, Keyboard ): self.controller.on_key_release(key, x, y) def on_specialkey_press(self, key, x, y): """On special key press""" if self.active: if self.controller and isinstance( self.controller, Keyboard ): self.controller.on_specialkey_press(key, x, y) def on_specialkey_release(self, key, x, y): """On special key release""" if self.active: if self.controller and isinstance( self.controller, Keyboard ): self.controller.on_specialkey_release(key, x, y) def on_mouse_motion(self, x, y): """On mouse motion""" if self.active: if self.controller and isinstance( self.controller, Mouse ): self.controller.on_mouse_motion(x, y) def on_mouse(self, button, state, x, y): """On mouse press/release""" if self.active: if self.controller and isinstance( self.controller, Mouse ): self.controller.on_mouse(button, state, x, y)
class TitleScreenState(EngineState): def __init__(self, engine): """ The game determines what is happening on screen based on what state the GameEngine instance has. """ self.engine = engine self.screen = Screen() self.res = self.engine.setsMgr.screenRes res = self.res # saying 'self.res' was making lines too long. :P # get/load the font self.font = FontManager().loadFont( 'Basic' ) # screen objects self.UI = {} self.UI['title'] = UIText("Breakin And Poppin"\ , pos=[res[0]*.01,res[1]*.10], font=self.font, scale=0.05) self.UI['start_server'] = UIText("Start a Server"\ , pos=[res[0]*0.5, res[1]*0.42], font=self.font, scale=0.04) self.UI['start_server'].center() self.UI['join_server'] = UIText("Join a Server"\ , pos=[res[0]*0.5, res[1]*0.5], font=self.font, scale=0.04) self.UI['join_server'].center() self.UI['quit'] = UIText("Quit"\ , pos=[res[0]*0.5, res[1]*0.58], font=self.font, scale=0.04) self.UI['quit'].center() self.titleBGImg = UIImage("TitleScreenBG.png"\ , pos=[0,0], size=res) self.selected = 'start_server' def renderFrame(self): if not self.screen: self.screen = Screen() self.screen.drawThis( self.titleBGImg ) selectionBox = UIImage("box.png", pos=self.UI[self.selected].pos, size=[(self.res[0]*0.05)*10, self.res[1]*0.05]) selectionBox.center() self.screen.drawThis( selectionBox ) for uiObj in self.UI.values(): # draw the background image firstly self.screen.drawThis( uiObj ) return self def on_key_press(self, key, x, y): """ On key press """ if key == '\x1b': return None elif key == chr(13): if self.selected == "start_server": self.statePath = 'start' return CreateServerState(self.engine) elif self.selected == "join_server": self.statePath = 'join' return JoinServerState(self.engine) elif self.selected == "quit": return None elif key == 101: if self.selected == "start_server": self.selected = "quit" elif self.selected == "join_server": self.selected = "start_server" elif self.selected == "quit": self.selected = "join_server" elif key == 103: if self.selected == "start_server": self.selected = "join_server" elif self.selected == "join_server": self.selected = "quit" elif self.selected == "quit": self.selected = "start_server" return self def on_mouse_motion(self, x, y): """ On mouse motion """ # check the mouse pos against all the choices if self.UI['start_server'].CollidePoint( (x,y) ): self.selected = "start_server" elif self.UI['join_server'].CollidePoint( (x,y) ): self.selected = "join_server" elif self.UI['quit'].CollidePoint( (x,y) ): self.selected = "quit" return self def on_mouse(self, button, state, x, y): """ On mouse release """ if button == GLUT_LEFT_BUTTON and state == GLUT_DOWN: # check the mouse pos against all the choices if self.UI['start_server'].CollidePoint( (x,y) ): self.engine.statePath = 'start' return CreateServerState(self.engine) if self.UI['join_server'].CollidePoint( (x,y) ): self.engine.statePath = 'join' return JoinServerState(self.engine) if self.UI['quit'].CollidePoint( (x,y) ): return None return self
class EngineState(): def __init__(self, engine): """ The game determines what is happening on screen based on what state the GameEngine instance has. """ # the game engine that owns this state self.engine = engine # TRYING TO DEPRECATE self.screen = Screen() self.res = self.engine.setsMgr.screenRes res = self.res # get/load the font self.font = FontManager().loadFont( 'JohnDoe' ) self.str_paused = UIText( "Paused", [res[0]*0.5, res[1]*0.5] , self.font, 35 ) self.str_paused.setVisible(False) gameWorld = self.engine.gameWorld #gameWorld.setPlayerType( 'Cop' ) gameWorld.setPlayerType( 'Robber' ) #gameWorld.getPlayer().setName( "Alfonso" ) # This is an optimization... # If using the Cop player type, use the smaller tiles if gameWorld.getPlayer().getType() == "Cop": gameWorld.setLevelByName( 'Level1XS' ) else: gameWorld.setLevelByName( 'Level1L' ) glutTimerFunc(50, self.engine.on_update, 50) def renderFrame(self): """ RenderFrame - Base Class """ if not self.screen: self.screen = Screen() self.screen.drawThis( self.str_paused ) return self def on_key_press(self, key, x, y): """ On key press """ if key == '\x1b': return None # for now, this means to "spawn a server" if key == 'x': if system() == "Linux" or system() == "Macintosh": Popen( [r'/usr/bin/python/python' ,os.path.join( self.engine.setsMgr.home_dir , 'StartServer.py' )] ) elif system() == "Windows": Popen([r'C:\Python25\python.exe' ,os.path.join( self.engine.setsMgr.home_dir , 'StartServer.py' )]) else: print "you are on an unsupported platform for spawning a server" # declare that this game instance is the server owner self.engine.serverOwner = True # for now, its "connect" elif key == 'c': self.engine.connect() elif key == 'v': self.engine.disconnect() elif key == 'g': self.str_paused.toggleVisible() self.engine.gameWorld.pause() return self def on_key_release(self, key, x, y): """ On key release """ return self def on_specialkey_press(self, key, x, y): """ On special key press """ return self def on_specialkey_release(self, key, x, y): """ On special key release """ return self def on_mouse_motion(self, x, y): """ On mouse motion """ self.engine.gameWorld.startGame() return self def on_mouse(self, button, state, x, y): """ On mouse """ return self def on_socket(self, packet): """ On socket """ self.gameTime = packet['time'] return self def update(self, elapsed): """ switches the state based on """ return self
class GameState(EngineState): def __init__(self, engine): """ The game determines what is happening on screen based on what state the GameEngine instance has. """ self.engine = engine self.res = self.engine.setsMgr.screenRes self.screen = None # get/load the font self.font = FontManager().loadFont( 'Basic' ) self.str_paused = UIText( "Paused", [self.res[0]*0.5, self.res[1]*0.5], self.font, 0.05 ) self.str_paused.setVisible(False) engine.gameWorld.setLevelByName( 'Level1L' ) engine.gameWorld.gameTime = 0.0 engine.gameWorld.startGame() #glutTimerFunc(300, self.print_game_world, 300) def print_game_world(self, elapsed): gW = self.engine.gameWorld tileSize = gW.level.getTileSize() peerPos = gW.peers.values()[0].pos print '' print '--- Gameworld ---' print 'Player = {', gW.player.playerName, ":", gW.player.pos, "}" print 'mapPixelPos = ', gW.player.pos[0] + gW.scrScroll[0]\ , gW.player.pos[1] + gW.scrScroll[1] print 'mapTilePos = ', gW.player.pos[0] / tileSize[0],\ gW.player.pos[1] / tileSize[1] print 'renderPos = ', gW.player.pos[0] - gW.scrScroll[0]\ , gW.player.pos[1] - gW.scrScroll[1] print ' ------ ------ ' print 'Peers = {', gW.peers.values()[0].playerName, ":", peerPos, "}" print 'mapTilePos = ', peerPos[0] / tileSize[0],\ peerPos[1] / tileSize[1] print 'renderPos = ', peerPos[0] - gW.scrScroll[0]\ , peerPos[1] - gW.scrScroll[1] print ' ------ ------ ' print 'TileSize = ', tileSize print '' glutTimerFunc(300, self.print_game_world, 300) def renderFrame(self): """ RenderFrame - Base Class """ if not self.screen: self.screen = Screen() scrSize = self.screen.getSize() #self.engine.gameWorld.positionPlayer( [scrSize[0],scrSize[1]] ) self.screen.drawThis( self.str_paused ) return self def on_key_press(self, key, x, y): """ On key press """ if key == chr(27): # Escape return ChoosePlayerState(self.engine) elif key == 'g': self.str_paused.toggleVisible() self.engine.gameWorld.pause() # controller self.engine.gameWorld.on_key_press(key, x, y) return self def on_key_release(self, key, x, y): """On key release""" # controller self.engine.gameWorld.on_key_release(key, x, y) return self def on_specialkey_press(self, key, x, y): """On special key press""" # controller self.engine.gameWorld.on_specialkey_press(key, x, y) return self def on_specialkey_release(self, key, x, y): """On special key release""" # controller self.engine.gameWorld.on_specialkey_release(key, x, y) return self def on_mouse_motion(self, x, y): """On mouse motion""" # controller self.engine.gameWorld.on_mouse_motion(x, y) return self def on_mouse(self, button, state, x, y): """On mouse press/release""" # controller self.engine.gameWorld.on_mouse(button, state, x, y) return self def update(self, elapsed): """ switches the state based on """ if self.engine.gameWorld.gameStatus == "winner": # Send a signal to the server that this player # seems to have won the game ( the server will # have to agree with our word ) # Go to the appropriate engine-state screen #self.engine.gameWorld = GameWorld() print 'switching to winner state' return WinnerState(self.engine) elif self.engine.gameWorld.gameStatus == "loser": # Go to the appropriate engine-state screen #self.engine.gameWorld = GameWorld() return LoserState(self.engine) else: return self
class WinnerState(EngineState): def __init__(self, engine): """ """ self.engine = engine self.res = self.engine.setsMgr.screenRes res = self.res self.screen = None # announce that the game is over #engine.announceGameOver( 'winner' ) self.engine.gameWorld.status = 'winner' self.engine.gameWorld.stopGame() self.font = FontManager().loadFont( 'Basic' ) self.UI = {} self.UI['nice_work'] = UIText("Nice Work!" , pos=[res[0]*0.5, res[1]*0.3], font=self.font, scale=0.047) self.UI['nice_work'].center() self.UI['cop_wins'] = UIText("You Caught The Robber!" , pos=[res[0]*0.5, res[1]*0.5], font=self.font, scale=0.04) self.UI['cop_wins'].center() self.UI['robber_wins'] = UIText("You made it home safe!" , pos=[res[0]*0.5, res[1]*0.5], font=self.font, scale=0.04) self.UI['robber_wins'].center() self.UI['press_esc'] = UIText("Press escape to continue" , pos=[res[0]*0.5, res[1]*0.75], font=self.font, scale=0.04) self.UI['press_esc'].center() self.titleBGImg = UIImage("black_bg.png"\ , pos=[0,0], size=res) def renderFrame(self): """ RenderFrame - Base Class """ if not self.screen: self.screen = Screen() self.screen.drawThis( self.titleBGImg ) self.screen.drawThis( self.UI['nice_work'] ) if self.engine.gameWorld.getPlayerType() == "Robber": self.screen.drawThis( self.UI['robber_wins'] ) elif self.engine.gameWorld.getPlayerType() == "Cop": self.screen.drawThis( self.UI['cop_wins'] ) self.screen.drawThis( self.UI['press_esc'] ) return self def on_key_press(self, key, x, y): """ On key press """ if key == chr(27): # Escape self.engine.disconnect() return TitleScreenState(self.engine) else: return self def on_mouse(self, button, state, x, y): """ On mouse press """ self.engine.disconnect() return TitleScreenState(self.engine)
class GameEngine(Client): """ The main game client: The game engine sends GLUT events to a gamestate class that manages what is happening on the screen. It also handles server communication. """ def __init__(self): """ Initializes the game client """ # since our game client is a client... Client.__init__(self) self.setsMgr = SettingsManager() self.res = self.setsMgr.screenRes self._InitGLUT_() self._InitGL_() # Make a screen object - we want to make the first here # so that we can ensure the size is set appropriately. # All other objects using the screen-singleton will assume # it is has already been sized and, thus, won't call setSize. self.screen = Screen() self.screen.setSize( self.res ) # be the first entity to create the managers self.rsrcMgr = TextureManager() self.fontMgr = FontManager() self.connected = False self.serverOwner = False self.serverName = "default" # the gameworld is mostly undefined at this point self.gameWorld = GameWorld() # this variable denotes for certain game states whether # the user 'start'-ed or 'join'-ed a server so they know # which state to return to when the user pushes 'back' self.statePath = None # create the initial game state self.gState = TitleScreenState(self) #self.gState = EngineState(self) def _InitGLUT_(self): """Initialize GLUT""" glutInit() #*# Create/Initialize the Window glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA) glutInitWindowPosition( 0,0 ) glutInitWindowSize( self.res[0], self.res[1] ) self.window = glutCreateWindow( "Breakin & Poppin" ) #*# setup the event handlers glutDisplayFunc(self.renderFrame) glutIdleFunc(self.on_tick) #glutReshapeFunc(self.changeSize) # keyboard glutKeyboardFunc( self.on_key_press ) glutKeyboardUpFunc( self.on_key_release ) glutIgnoreKeyRepeat( 1 ) # !=0 disables key repeat callbacks glutSpecialFunc( self.on_specialkey_press ) glutSpecialUpFunc( self.on_specialkey_release ) glutMouseFunc( self.on_mouse ) glutPassiveMotionFunc( self.on_mouse_motion ) #glutFullScreen() def _InitGL_(self): """Initialize GL""" # Set up the rendering environment # setup the orthographic projection (firstly) glMatrixMode( GL_MODELVIEW ) glPushMatrix() glLoadIdentity() # Set up the orthographic projection glOrtho(0, self.res[0], 0, self.res[1], -1, 1) # invert the y axis, down is positive glScalef(1, -1, 1) # mover the origin from the bottom left corner # to the upper left corner glTranslatef(0, -self.res[1], 0) # turn off the lighting and depth testing glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT ) glDisable( GL_LIGHTING ) glDisable( GL_DEPTH_TEST ) glDisable( GL_DITHER ) def on_key_press(self, key, x, y): """On key press""" if self.gState: self.gState = self.gState.on_key_press(key, x, y) def on_key_release(self, key, x, y): """On key release""" if self.gState: self.gState = self.gState.on_key_release(key, x, y) def on_specialkey_press(self, key, x, y): """On special key press""" # game state if self.gState: self.gState = self.gState.on_key_press(key, x, y) def on_specialkey_release(self, key, x, y): """On special key release""" # game state if self.gState: self.gState = self.gState.on_key_release(key, x, y) def on_mouse_motion(self, x, y): """On mouse motion""" # game state if self.gState: self.gState = self.gState.on_mouse_motion(x, y) def on_mouse(self, button, state, x, y): """On mouse press/release""" # game state if self.gState: self.gState = self.gState.on_mouse(button, state, x, y) def on_update(self, elapsed): """ The function that updates every object's animation status (45ms) """ # update the game state if self.gState: self.gState = self.gState.update(elapsed) # gameworld self.gameWorld.update(elapsed) # gamestate glutTimerFunc(50, self.on_update, 50) def on_socket( self, elapsed): """ """ # call the base class version (returns the packet) packet = Client.on_socket(self, elapsed) if packet != None: #print 'client - recv - got a packet' self.readPacket( packet ) # the real meat of this else: # Oh well, no packet for some reason pass glutTimerFunc(20, self.on_socket, 20) ### def readPacket(self, packet): """ This interpets a packet sent by the server """ # This case is usually handled by the GameEngine side # (But this class isn't supposed to know that. :P) if packet['type'] == 'update': #print 'Client : Got an update : ', packet if self.connected: if self.gState: # let the game state handle some bih'ness self.gState= self.gState.on_socket(packet) if self.gameWorld: self.gameWorld.on_socket(packet) # if the level is different or non-existant, load it #if not self.gameWorld.getLevel() \ # or (packet['level'] != self.gameWorld.getLevelName()): # self.gameWorld.setLevelByName( packet['level'] ) if packet['type'] == 'message': #print 'Client : Got a message : ', packet # Connection Reset by Peer if 'CRbP' in packet: print 'Disconnected: The server connection is dead.' self.disconnect() # The server is full if 'ServerFull' in packet: print 'Disconnected: The server is full.' # this is just like getting CRbP for now # but the response to the user should # be different at some point. self.disconnect() if 'CurrentLevel' in packet: #self.engine.gameWorld.setLevel( packet['CurrentLevel'] ) print 'Current level is ', packet['CurrentLevel'] self.gameWorld.setLevelByName(packet['CurrentLevel']) if 'NextLevel' in packet: print 'Next Level is ', packet['NextLevel'] if 'GameStatus' in packet: self.gameWorld.stopGame() if packet['GameStatus'] == 'winner': self.gState = LoserState(self) elif packet['GameStatus'] == 'loser': self.gState = WinnerState(self) def on_tick(self): """Timer event: on tick""" # kill the app if there is no state if not self.gState: self.on_close() # render the scene glutPostRedisplay() def on_close(self): """On close""" # leave the server self.disconnect() glutDestroyWindow(self.window) sys.exit() def renderFrame(self): """The glut display function""" # clear the buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Draw the game world if self.gameWorld: self.screen.drawThis( self.gameWorld ) # Render if we have a state if self.gState: # the state passes any objects the screen to be rendered self.gState.renderFrame() # The screen draws all objects it has been passed self.screen.draw() # Dump the contents to the screen glutSwapBuffers()
from engine import Screen, World, Tile, Entity from systems import System, GraphicsSystem, ControlSystem, SpriteSystem from components import Component, Position, Camera, Control, State, Sprite DEBUG = True playertile = (0, 0) playerposition = (0, 0) pygame.init() pygame.display.set_caption('~ R I K \' S G A M E ~') pygame.display.set_icon(pygame.image.load('icon.png')) clock = pygame.time.Clock() w = World(size=1024, tilesize=32) s = Screen(800, 800) gs = GraphicsSystem() cs = ControlSystem() ss = SpriteSystem() p = Entity(w) p.camera = Camera(0, 0, 800, 800, track=True, entitytotrack=p) p.position = Position(0, 0, 32, 32, 2) p.control = Control(pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT) p.state = State() p.sprite = Sprite() p.sprite.sprites['idle'] = [ pygame.image.load('images/player/idle.png'), pygame.image.load('images/player/idle2.png'),
def Main(): Screen.WakeScreen() Timer.SetTimeOut('sleep_screen', 7, Screen.SleepScreen, permanent=True) RefreshDesktop()
def Thread(): serial_port = SystemState.PhoneState.serial_port # Infinite loop to pass found messages to InterruptSystem() in cobblr. while True: # Looks for incomming serial messages (calls, texts, etc). try: serial_data = serial_port.readlines() except serial.SerialException: serial_data = [] # Evil. serial_data = ParseSerialData(serial_data) if len(serial_data) > 0: print 'serial data: ', serial_data # Call related interrupts if len(serial_data) > 0: message_type = serial_data[0] if message_type == 'RING': serial_data = serial_data[1].strip() stripped_number = serial_data.split('"')[1].strip('"') Screen.WakeScreen() # Setting RING timeout timer to hang up if NO CARRIER is not received. callback = Menu.Back callback_args = {'change_application': True} Timer.DeleteTimeOut('ring_timeout') Timer.SetTimeOut('ring_timeout', 6, callback, callback_args) # Changes menu callback_args = { 'screen_mode': 3, 'application': 'phone', 'change_application': True, 'store_history': False } message = { 'callback': Menu.JumpTo, 'callback_args': callback_args } SystemState.interrupt_queue.put(message) # Print's 'Incomming Call' on the screen. callback_args = { 'permatext': True, 'text': 'Incomming Call', 'text_type': 'message' } message = { 'callback': TextWriter.Write, 'callback_args': callback_args } SystemState.interrupt_queue.put(message) # Print's the phone number on the screen. callback_args = { 'permatext': True, 'text': stripped_number, 'text_type': 'subtext' } message = { 'callback': TextWriter.Write, 'callback_args': callback_args } SystemState.interrupt_queue.put(message) if message_type == 'ATA': Timer.DeleteTimeOut('ring_timeout') # If someone hang's up, go back to the lass application. if message_type == 'NO CARRIER': Timer.DeleteTimeOut('ring_timeout') callback_args = {'change_application': True} message = { 'callback': Menu.Back, 'callback_args': callback_args } SystemState.interrupt_queue.put(message)