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
