def __init__(self, uuid, **kwargs): # call my parent super().__init__(uuid, mass=spot_get('sv_ball_mass'), size=spot_get('ball_size'), **kwargs) # pymunk.Body elasticity for this paddle self.box.elasticity = 1.0 # Ball top speed self.velocity_limit = spot_get('sv_ball_max_velocity') # Collision type for this body self.box.collision_type = self.CTYPE
def __init__(self, *, width, height, **kwargs): """Constructor Kwargs: width(int): width of the scene in pixels height(int): height of the scene in pixels kwargs(dict, optional): Arbitrary keyword arguments """ super().__init__(**kwargs) # Set scene dimensions self._window_width = width self._window_height = height # Set up the actual EntityManager self._ent_mgr = EntityManager() # set gravity self._ent_mgr.gravity = spot_get("sv_gravity") # Board self._board = Board(width, height, self._ent_mgr) # Players (and their related information) will be held in here self._players = {} # Register entities self._ent_mgr.register_class("ent_player", PlayerPaddle) self._ent_mgr.register_class("ent_ball", Ball) # Paddle impulse, top speed and artificial friction self._paddle_impulse = spot_get("sv_paddle_impulse") self._paddle_max_velocity = spot_get("sv_paddle_max_velocity") self._paddle_friction = spot_get("sv_paddle_friction") # Create the actual ball self.create_ball() # Current state self._state = self.ST_WAITING_FOR_PLAYER # Set up tick interval on server self._tickrate = 1.0 / spot_get("tickrate") pyglet.clock.schedule_interval(self.tick, self._tickrate) # this method wis called each time the ball # collides with either the left or the right boundary # on the board self._ent_mgr.add_collision_handler(Ball.CTYPE, Board.BOUNDARY_CTYPE_LEFT, begin=self._scored_left) self._ent_mgr.add_collision_handler(Ball.CTYPE, Board.BOUNDARY_CTYPE_RIGHT, begin=self._scored_right)
def draw_scores(self): """Draw scores""" # the scores are shown according to players base_str_format = "{} {}" if self._number_me == 1: scores_label_format = base_str_format.format( self._score_me, self._score_foe ) else: scores_label_format = base_str_format.format( self._score_foe, self._score_me ) # Set up size and position of scores label if self._server_state == Scene.ST_SCORE: font_size = 100 scores_y = self._window.height // 2 else: font_size = 48 scores_y = spot_get('cl_scores_position')[1] # set properties on label self._scores_label.y = scores_y self._scores_label.font_size = font_size self._scores_label.text = scores_label_format # draw the scores label self._scores_label.draw()
def __init__(self, uuid, host=None, port=None, number=None, foe=None, **kwargs): """Constructor Kwargs: host(str): Client address associated with this player port(str): Source port of client address number(int): Player number foe(str): Opponent UUID """ # call my parent super().__init__(uuid, mass=spot_get('sv_paddle_mass'), size=spot_get('paddle_size'), **kwargs) # pymunk.Body elasticity for this paddle self.box.elasticity = 1.0 # collision type for this body self.box.collision_type = self.CTYPE # paddle top speed self.velocity_limit = spot_get('sv_paddle_max_velocity') # Networking information for this player self.host = host self.port = port # Player number self.number = number # This player's opponent self.foe = foe # Initial flags for this player self.ready = False self.score = 0
def reset_ball(self): """Reset ball position""" # Set initial position for this ball # self._ball.reset_forces() self._ball.velocity = (0, 0) self._ball.position = spot_get("ball_position_start") # FIXME: do something better # Set initial impulse on the ball self._ball.apply_impulse((-1500, 0))
def _reset_player(self, player): """Reset values on a player""" # Calculate initial position player_position_x, player_position_y = spot_get("paddle_position_start") # player 2's position on the other side of the screen if player.number == 2: player_position_x = self._window_width - player_position_x # Set initial position for this player player.position = player_position_x, player_position_y # Reset physics on this player # player.reset_forces() player.velocity = (0, 0) if self._state == self.ST_BEGIN: # Reset score player.score = 0 # Ready state for this player player.ready = False
def _round_goback(self, dt): if any([player.score == spot_get("sv_score_max") for player in self._players.values()]): self._state = self.ST_GAME_SET else: self._state = self.ST_PLAYING
def __init__(self, *, machine): """Constructor Kwargs: machine(StateMachine): parent state machine """ # Call my parent super().__init__(machine=machine, fade_in=True) # base image self._img = self.sorcerer.get_resource('sprite_sheet') # logo sprite _logo_region = self._img.get_region(96, 0, 464, 256) _logo_region.anchor_x = _logo_region.width // 2 _logo_region.anchor_y = _logo_region.height // 2 self._logo_sprite = pyglet.sprite.Sprite(_logo_region) self._logo_sprite.set_position( self.window.width // 2, self.window.height // 2 ) # ball sprite _ball_region = self._img.get_region(32, 32, 64, 64) _ball_region.anchor_x = _ball_region.width // 2 _ball_region.anchor_y = _ball_region.height // 2 self._ball_sprite = pyglet.sprite.Sprite(_ball_region) self._ball_sprite.set_position( self._logo_sprite.x + _logo_region.width//2 - 16, self.window.height//2 - _logo_region.height//2 + 36 ) # Toggle flags self._show_press_start = True # This is used for _comp_label animation self._key_pressed = False # has been a key pressed? # and this as well self.snd_begin = self.sorcerer.create_sound( 'snd_begin', file_name='begin.wav' ) # Companion label self._comp_label = self.create_label( "Press ANY KEY to play!", font_size=24, font_name=FONT_SECONDARY, y=32, anchor_y='baseline' ) # Github label self._github_label = self.create_label( pkg_url, font_size=16, font_name=FONT_SECONDARY, anchor_x='right', anchor_y='top', y=self.window.height-8, x=self.window.width-8 ) # network text net_txt = "net-{}".format(Packet.PROTO_VERSION) if spot_get("argv")['--lz4']: net_txt = "{}+lz4".format(net_txt) # Version label self._version_label = self.create_label( "v{} ({})".format(pkg_version, net_txt), font_size=14, font_name=FONT_SECONDARY, anchor_x='left', anchor_y='top', y=self.window.height-8, x=8 ) # set the background color self.set_background_color(*colors.LIGHT_BLUE)
def __init__(self, *, window, ball_position, **kwargs): """Constructor Kwargs: ball_position(int,int): ball initial position kwargs(dict, optional): Arbitrary keyword arguments """ # Call the parent super().__init__(**kwargs) # This will hold the UUID assigned by a server # and used on further requests self._id = None # get the sorcerer to use resources self._sorcerer = spot_get('game_object').sorcerer # sprite sheet is allocated at this point self._img = self._sorcerer.create_image( 'sprite_sheet', file_name='sprites.png' ) # paddle image region paddle_width, paddle_height = spot_get('paddle_size') self._paddle_region = self._img.get_region( 0, 0, paddle_width, paddle_height ) # centered anchor as required by pymunk bodies at the server side self._paddle_region.anchor_x = self._paddle_region.width // 2 self._paddle_region.anchor_y = self._paddle_region.height // 2 # board image region self._board_region = self._img.get_region(0, 256, 800, 600) self._board_region.anchor_x = 0 self._board_region.anchor_y = 0 # board sprite self._board_sprite = pyglet.sprite.Sprite(self._board_region) self._board_sprite.set_position(0, 0) # ball image region ball_width, ball_height = spot_get('ball_size') self._ball_region = self._img.get_region( 32, 0, ball_width, ball_height ) # centered anchor as required by pymunk bodies at the server side self._ball_region.anchor_x = self._ball_region.width // 2 self._ball_region.anchor_y = self._ball_region.height // 2 # sprites self._paddle_me_sprite = pyglet.sprite.Sprite(self._paddle_region) self._paddle_foe_sprite = pyglet.sprite.Sprite(self._paddle_region) self._ball_sprite = pyglet.sprite.Sprite(self._ball_region) # Sprites are invisible at first self._paddle_me_sprite.visible = False self._paddle_foe_sprite.visible = False self._ball_sprite.visible = False # paddles initial position self._paddle_me_x = 0 self._paddle_me_y = 0 self._paddle_foe_x = 0 self._paddle_foe_y = 0 # ball position self._ball_x, self._ball_y = ball_position # paddles initial velocity self._paddle_me_vx = 0 self._paddle_me_vy = 0 self._paddle_foe_vx = 0 self._paddle_foe_vy = 0 # ball velocity self._ball_vx = 0 self._ball_vy = 0 # Whether the client has succesfully connected to a server self._me_connected = False # Whether a foe player is present in the game self._foe_connected = False # Whether the client is currently pressing up or down keys self._key_move_up = False self._key_move_down = False # Time scale (for in-client physics) self._current_time = time.time() self._dt = 0.0 # time delta # Command rate # How much command is this client going to send per second? self._cmdrate = 1.0 / spot_get('cl_cmdrate') pyglet.clock.schedule_interval(self.send_commands, self._cmdrate) ################################### # Set up updates interval on client ################################### # if True, this client will ignore any incoming data self._update_lock = False # Updates frequence self._update_rate = 1.0 / spot_get('cl_updaterate') pyglet.clock.schedule_interval( self.update_from_server, self._update_rate ) # Initial state on server self._server_state = None # Ready the player? self._key_ready = False # game window self._window = window # scores label scores_x, scores_y = spot_get('cl_scores_position') self._scores_label = utils.create_label( window=self._window, x=scores_x, y=scores_y, font_size=48, ) self._scores_label.set_style('color', colors.GRAY1 + (255,)) # scores themselves self._score_me = 0 self._score_foe = 0