Pong

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.
org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>Second Example: Pong — The Pygame SGE 0.8.0 documentation</titl e> <link rel="stylesheet" href="_static/default.css" type="text/css" /> <link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <script type="text/javascript"> var DOCUMENTATION_OPTIONS = { URL_ROOT: '', VERSION: '0.8.0', COLLAPSE_INDEX: false, FILE_SUFFIX: '.html', HAS_SOURCE: true }; </script> <script type="text/javascript" src="_static/jquery.js"></script> <script type="text/javascript" src="_static/underscore.js"></script> <script type="text/javascript" src="_static/doctools.js"></script> <link rel="top" title="The Pygame SGE 0.8.0 documentation" href="index.html" /> <link rel="next" title="Global Variables and Constants" href="globalvars.htm l" /> <link rel="prev" title="First Example: Hello, world!" href="hello_world.html " /> </head> <body> <div class="related"> <h3>Navigation</h3> <ul> <li class="right" style="margin-right: 10px"> <a href="genindex.html" title="General Index" accesskey="I">index</a></li> <li class="right" > <a href="globalvars.html" title="Global Variables and Constants" accesskey="N">next</a> |</li> <li class="right" > <a href="hello_world.html" title="First Example: Hello, world!" accesskey="P">previous</a> |</li> <li><a href="index.html">The Pygame SGE 0.8.0 documentation</a> »< /li> </ul> </div> <div class="document"> <div class="documentwrapper"> <div class="bodywrapper"> <div class="body"> <div class="section" id="second-example-pong"> <h1>Second Example: Pong<a class="headerlink" href="#second-example-pong" title=
"Permalink to this headline"></a></h1> Now that you’ve seen the basics of the SGE, it’s time to create a n actual game. Although Pong might seem extremely simple, it will give you a great foundation for developing more complex games in the future. <div class="section" id="setting-up-the-project"> <h2>Setting Up the Project<a class="headerlink" href="#setting-up-the-project" t itle="Permalink to this headline"></a></h2> I am going to set up my project in “~/pong”, and the game script is going to be called “pong.py”. I am going to open pong.py and add the appropriate shebang, my copyright notice (I am choosing the CC0 license), and my imports. This is what I have so far: <div class="highlight-python"><div class="highlight"><pre>#!/usr /bin/env python3 # Pong # Written in 2013 by Julian Marchant <onpon4@riseup.net> # # To the extent possible under law, the author(s) have dedicated all # copyright and related and neighboring rights to this software to the # public domain worldwide. This software is distributed without any # warranty. # # You should have received a copy of the CC0 Public Domain Dedic ation # along with this software. If not, see # <http://creativecommons.org/publicdomain/zero/1.0/>.</sp an> import sge </pre></div> </div> </div> <div class="section" id="global-variables"> <h2>Global Variables<a class="headerlink" href="#global-variables" title="Permal ink to this headline"></a></h2> For our implementation of Pong, we are going to store a few variables that can be accessed conveniently by everybody: in a word, “global” variables. Of course, one way we could do this is to actually use global variables. However, using this approach has a significant disadvantage: in Python, local variables take precedence over global variables, so to assign to a global variable within a function, you have to declare it with the <tt class="docutils literal">global</tt> keyword. If w e forget to do this, the resulting bugs can be difficult to solve. So we are going to use a different approach: a container class. Put simply, this is a class that contains only class attributes that we will use as variables. Our container class looks like this: <div class="highlight-python"><div class="highlight"><pre>class glob: # This class is for global variables. While not necessary, using a
# container class like this is less potentially confusing th an using # actual global variables. player1 = Non e player2 = Non e ball = None hud_sprite = None bounce_sound = None bounce_wall_sound = None score_sound = None game_in_progress = True </pre></div> </div> I call the class “glob” as a shorthand for “global” ( the shorthand is necessary since <tt class="docutils literal">global</tt > is a keyword in Python). The reason for having all of these variables will be explained later when we actually use them. </div> <div class="section" id="the-game-class"> <h2>The Game Class<a class="headerlink" href="#the-game-class" title="Permalink to this headline"></a></h2> For our <a class="reference internal" href="Game.html#sge.Game" title="sge.Ga me"><tt class="xref py py-class docutils literal">sge.Game</sp an></tt></a> class, we want to of course provide a way to exit the game, and in this case, we are also going to provide a way to pause the game. Just for the heck of it, let’s also allow the player to take a screenshot by pressing F8. With those goals in mind, our Game class is defined as follows: <div class="highlight-python"><div class="highlight"><pre>class Game(sge.Game): def event_key_press(self, key, char): if key == 'f8': sge.Sp rite.from_screenshot().save('screenshot.jpg')</s pan> elif key = = 'escape': self. event_close() elif key 
in ('p', 'enter'): self. pause() def event_close(self): m = " Are you sure you want to quit?" if sge.</s pan>show_message(m , ("No ", "Yes"<spa n class="p">)): self. end() def event_paused_key_press<sp an class="p">(self, key, char): if key == 'escape': # This allows the player to still exit while the gam e is # paused, rather than having to unpause first. self. event_close() else: self. unpause() def event_paused_close(self): # This allows the player to still exit while the game is paused, # rather than having to unpause first. self.even t_close() </pre></div> </div> The first event we define is the key press event. When the F8 key is pressed, we create a sprite from a screenshot using the <a class="reference internal" href="Sprite.html#sge.Sprite.from_screenshot" titl e="sge.Sprite.from_screenshot"><tt class="xref py py-meth docutils literal"><spa n class="pre">sge.Sprite.from_screenshot()</tt></a> class method, then sa ve that sprite as “screenshot.jpg”. When the Esc key is pressed, we close the game by calling the close event. When the “P” or Enter key is pressed, we u se <a class="reference internal" href="Game.html#sge.Game.pause" title="sge.Game.pa use"><tt class="xref py py-meth docutils literal">sge.Game.pau se()</tt></a> to pause the game. “P” and Enter are checked together by grouping them in a tuple and then using the <tt class="docutils lite ral">in</tt> operator, rather than checking them separately, because it’s easier to read and less verbose. The next event we define is the close event. Unlike our last example,
here, we first ask the player to confirm whether or not they want to close before actually closing. <a class="reference internal" href="functions.ht ml#sge.show_message" title="sge.show_message"><tt class="xref py py-func docutil s literal">sge.show_message()</tt></a> returns a number representing what button was pressed, with <tt class="docutils literal">0</tt> as the first number, so we are able to simplify the check of what button was pressed with a simple hack: the first button (button 0) is the “No” button, and the second button (button 1) is the “Yes” button. The numbers these buttons return correspond to <tt class="xref py py-const docutils literal">False</tt> and <tt class="xref py py-const docutils literal" >True</tt>, respectively. Next, we need to define “paused” events, because normal events ar e suspended while the game is paused. The “paused” close event just do es the same thing as the regular “close” event, to allow the game to be exited without unpausing the game first. The “paused” key event, on the other hand, unpauses the game if any key other than the Esc key (which ends the game) is pressed. </div> <div class="section" id="the-player-class"> <h2>The Player Class<a class="headerlink" href="#the-player-class" title="Permal ink to this headline"></a></h2> The Player class is going to be a subclass of <a class="reference internal" h ref="StellarClass.html#sge.StellarClass" title="sge.StellarClass"><tt class="xre f py py-class docutils literal">sge.StellarClass</tt></ a>, which is the class that represents individual objects in the SGE. This class is used for players, bullets, floors, walls, and pretty much anything else you can think of. For the Player class, we are actually going to do something a bit unusual: we are going to extend <a class="reference internal" href="StellarClass .html#sge.StellarClass.__init__" title="sge.StellarClass.__init__"><tt class="xr ef py py-meth docutils literal">sge.StellarClass.__init__()</s pan></tt></a> (the constructor method): <div class="highlight-python"><div class="highlight"><pre>class Player(sge .StellarClass): def __init__( self, play er=1):</sp an> if player == 1: self. up_key = "w" self. down_key = "s" x = 3 2 glob.p layer1 = self self.
hit_direction = 1 else: self. up_key = "up" self. down_key = "down" x = sg e.game.</sp an>width - 32</sp an> glob.p layer2 = self self. hit_direction = -1 y = sge</s pan>.game.height / 2 super().__init__(x, y, 0, sprite<s pan class="o">="paddle") </pre></div> </div> As you can see, our extended <tt class="xref py py-meth docutils literal"><sp an class="pre">__init__()</tt> now only takes one argument indicating the player: <tt class="docutils literal">1 </tt> for the left player, and any other value (such as <tt class="docutils literal">2</tt>) for the right player. Everything else is then inferred from that: the controls (you will see why we are storing the controls like this in a minute), the horizontal location, and the direction the paddle hits (<tt class="docutils literal">1</spa n></tt> for right, <tt class="docutils literal">-1</tt> for left). As a bonus, we also use this information to decide what “global” variable to assign the player to: <tt class="xref py py-attr docutils literal">glob.player1</tt> if it is the left player, or <tt class="xref py py-attr docutils literal">glob.player2</spa n></tt> if it is the right player. Keep in mind that you must never override <a class="reference internal" href="StellarClass.html#sge.StellarClass.__init__" title="sge.StellarClass.__init__"><tt class="xref py py-meth docutils literal"> sge.StellarClass.__init__()</tt></a>; you should only e xtend it. This is why we have the last line. The <tt class="xref py py-func docutils literal"><sp an class="pre">super()</tt> function allows us to call the corresponding method in the parent class, making our new <tt class="xref py py-meth docutils literal">__init__() </tt> an extension rather than an override. Next up, we need to add code to allow the paddles to move. The easiest place to do this is in the step event: <div class="highlight-python"><div class="highlight"><pre>def</s pan> event_step( self, time_passed):
# Movement key_motion = ( sge.get_key _pressed(self.down_key) - sge.get_key_pressed(self<s pan class="o">.up_key)) self.yvelocit y = key_motion * PADDLE_SPEED # Keep the paddle inside the window if self.</spa n>bbox_top < 0 : self.bbox _top = 0 elif self.</s pan>bbox_bottom > sge.game .height: self.bbox _bottom = sge.game.hei ght </pre></div> </div> The first thing we do is check whether the paddle’s assigned down key i s pressed and whether the assigned up key is pressed. The simplest way to do this is to use an if statement, but instead, I subtracted the result for the up key from the result for the down key. Since the returned values are equivalent to <tt class="docutils literal">1 </tt> and <tt class="docutils literal">0</tt> in subtra ction, key_motion will become <tt class="docutils literal">-1</tt> if only the up key is pressed, <tt class="docutils literal">1</tt> if only the down key is pressed, and <tt class="docutils literal">0</tt> if neither or both of the keys are pressed. This method of figuring out the desired direction not only is a lot simpler than an if statement, but also handles the condition of opposite directions being pressed at the same time properly. Since <tt class="docutils literal">-1</tt> is up, <t t class="docutils literal">1</tt> is down, and <tt clas s="docutils literal">0</tt> is no movement, I now just need to multiply <tt class="docutils literal">key_motion</tt> by some constant value (the paddle speed I wish to use) to get the desired vertical velocity. The name I have chosen for this constant is <tt class="xref py py-const docutils literal">PADDLE_SPEED</tt>. Attempting to use an undefined constant will cause an error, so let’s define it now: <div class="highlight-python"><div class="highlight"><pre>PADDLE _SPEED = 4 </pre></div> </div> This should be placed in the global namespace, probably right after your
imports. I chose <tt class="docutils literal">4</tt> t o be the value of this constant because I found it to be the best balance between precision and speed. As you may have figured out, <tt class="xref py py-attr docutils literal"><sp an class="pre">sge.StellarClass.yvelocity</tt> is a special attribute. In simple terms, the SGE automatically adds this number to the vertical position of the object every frame, creating an illusion of continuous movement. With just this, the players will be able to move the paddles off of the screen, and we don’t want this. To prevent it, we check the paddle’ s <tt class="xref py py-attr docutils literal">sge.StellarClass. bbox_top</tt> and <tt class="xref py py-attr docutils literal">sge.StellarClass. bbox_bottom</tt> attributes to see if they are above or below the screen, respectively, and then set them to the respective edge of the screen if they are. </div> <div class="section" id="the-ball-class"> <h2>The Ball Class<a class="headerlink" href="#the-ball-class" title="Permalink to this headline"></a></h2> Once again, the Ball class is going to be a subclass of <a class="reference internal" href="StellarClass.html#sge.StellarClass" title="s ge.StellarClass"><tt class="xref py py-class docutils literal">sge.StellarClass</tt></a>. Once again, we are going to start by extending the constructor method: <div class="highlight-python"><div class="highlight"><pre>class Ball(sge.StellarClass ): def __init__( self): x = sge</s pan>.game.width / 2 y = sge</s pan>.game.height / 2 super().__init__(x, y, 1, sprite<s pan class="o">="ball") </pre></div> </div> This extension is more simple than <tt class="xref py py-class docutils liter al">Player</tt>‘s: our extension simply removes all arguments from the constructor method and hard-codes values to pass on to <a class="reference internal" href="StellarClass.html#sge.S tellarClass.__init__" title="sge.StellarClass.__init__"><tt class="xref py py-me th docutils literal">sge.StellarClass.__init__()</tt></ a>. When the ball is created, we want to immediately serve it to a player. To achieve that, we are going to define the create event, which occurs whenever an object of the class is created: <div class="highlight-python"><div class="highlight"><pre>def</s pan> event_create(self):
self.serve</s pan>() </pre></div> </div> We are defining <tt class="xref py py-func docutils literal">Ball.serve()</tt> to achieve serving the ball because there are other situations when the ball needs to be served, namely whenever a player scores. This will be our serve method: <div class="highlight-python"><div class="highlight"><pre>def</s pan> serve(self, direction= 1): self.x = self.<s pan class="n">xstart self.y = self.<s pan class="n">ystart # Next round self.xvelocit y = BALL_START_SPEED * direction self.yvelocit y = 0 </pre></div> </div> In a nutshell, we set the ball back to the its starting position (which is the center of the screen) and reset its movement based on an argument called <tt class="docutils literal">direction</tt>, whi ch will be <tt class="docutils literal">1</tt> (for rig ht) or <tt class="docutils literal">-1</tt> (for left). We multiply this by a constant called <tt class="xref py py-const docuti ls literal">BALL_START_SPEED</tt>; let’s define this constant now, right below our definition of <tt class="xref py py-const docutils literal">PADDLE_SPEED</sp an></tt>: <div class="highlight-python"><div class="highlight"><pre>BALL_S TART_SPEED = 2 </pre></div> </div> As it is, the ball will pass through the paddles, which is not what we want; we want the ball to bounce off of the paddles. We will achieve that with a collision event: <div class="highlight-python"><div class="highlight"><pre>def</s pan> event_collision(self, other): if isinstance (other, Pla yer): if other.hit_direction == 1: self. bbox_left = other.bbox_right + 1 self. xvelocity = min(abs(self.xvelocity) + BALL_ACCELERATION<s pan class="p">, BALL_MAX_SPEED) else: self. bbox_right = other.bbox_left - 1 self. xvelocity = max(-abs (self.xvel ocity) - BA LL_ACCELERATION, -BALL_MA X_SPEED) self.yvel ocity += ( self.y -</s pan> other.y) * PADDLE_VERTIC AL_FORCE </pre></div> </div> We also need to define three more constants: <div class="highlight-python"><div class="highlight"><pre>BALL_A CCELERATION = 0.2 BALL_MAX_SPEED = 15 PADDLE_VERTICAL_FORCE = 1 / 12 </pre></div> </div> The collision event occurs whenever another object touches this object. when this happens, we check if the other object is an instance of the <tt class="xref py py-class docutils literal">Player</t t> class; if it is, we check the other object’s <tt class="xref py py-attr docutils literal">hit_direction</sp an></tt>; if it’s <tt class="docutils literal">1< /tt>, we place the left side of the ball’s bounding box just to the right of the right side of the paddle&#821 7;s bounding box, then we make the ball’s horizontal velocity positive and add a constant, <tt class="xref py py-const docutils literal"> BALL_ACCELERATION</tt>, to it; this will cause the ball to slowly speed up as the game progresses. If <tt class="xref py py-attr docutils literal">hit_direction</sp an></tt> is something other than <tt class="docutils literal"> 1</tt>, we assume that the paddle hits to the left; the behavior is identical to the behavior of hitting to the right, but opposite. Although accelerating the ball makes the gameplay more fun, we must not let the ball go too fast. Remember that movement is much like an animation. The ball changes its position from one position to another; the greater the speed, the bigger the difference. Movement perceived is only an illusion. As a result, if the ball goes too fast, it can
pass right through a paddle without a collision ever being detected. To prevent this, we limit the speed the ball can go at by a constant; in general, a good value to choose is one that is slightly less than the width (in the case of horizontal movement) or height (in the case of vertical movement) of the two objects that need to detect collisions with each other added together. This method only works reliably if one of the objects is not moving; if both of the objects are moving, what maximum speed they should be moving at is more complicated, but in this case, the paddle is horizontally stationary. We are later going to set the width of both the paddle and the ball to <tt class="docutils literal">8</tt>, so we will set the maximum ball speed to <tt class="docutils literal">15</ tt> (i.e. <tt class="docutils literal">8 + 8 - 1</tt>). The game would be rather dull if the players couldn’t control the direction of the ball, so we allow the players to control the ball by adding the difference between the ball and paddle’s vertical positions (which are going to be their centers) multiplied by a constant to the ball’s vertical velocity. There are two remaining problems with our ball class: first, if the ball passes a player, it doesn’t return. Second, if the ball reaches the edge of the screen, it will just float off and be impossible to retrieve by the receiving player. This actually would be realistic behavior, but it wouldn’t be very fun. We will fix both of these problems in the step event: <div class="highlight-python"><div class="highlight"><pre>def</s pan> event_step( self, time_passed): # Scoring if self.</spa n>bbox_right < 0: self.serv e(-1) elif self.</s pan>bbox_left > sge.game.width: self.serv e(1) # Bouncing off of the edges if self.</spa n>bbox_bottom > sge.game.height: self.bbox _bottom = sge.game.hei ght self.yvel ocity = -a bs(self.yvelocity) elif self.</s pan>bbox_top < 0: self.bbox _top = 0 self.yvel ocity = abs(self.yve locity) </pre></div> </div> Since we have our <tt class="xref py py-meth docutils literal">serve()</tt> method, we simply need to call it when the ball passes one of the players and goes horizontally outside the screen. For bouncing off the edges, we use a similar method to the method we used to keep the paddles inside the view; the main difference is we also set the ball’s vertical velocity to move away from the edge; if it collided with the bottom, the vertical velocity is made negative, and if it collided with the top, the vertical velocity is made positive. </div> <div class="section" id="the-main-function"> <h2>The main Function<a class="headerlink" href="#the-main-function" title="Perm alink to this headline"></a></h2> Let’s make our Pong game playable now by defining the <tt class="xref p y py-func docutils literal">main()</tt> function: <div class="highlight-python"><div class="highlight"><pre>def</s pan> main(): # Create Game object Game(640</spa n>, 480, fps=120<spa n class="p">) # Load sprites paddle_sprite = sge.Sprite(ID=" paddle", width=8, height=48, origin_x=4, origin_y=24) paddle_sprite. draw_rectangle(0, 0, paddle_sprite.width, paddle_sprite.height, fill="white"<s pan class="p">) ball_sprite = sge.Sprite( ID="ba ll", width=8, he ight=8,</s pan> origin_x=4,
origin_y=</s pan>4) ball_sprite.dr aw_rectangle(0, 0, b all_sprite.width, ball_sprite.height, fill=</spa n>"white") # Load backgrounds layers = (</sp an>sge.BackgroundL ayer("ball", sge.game.width / 2, 0, -10000 , xrepeat =False),) background = s ge.Background (layers, "black") # Create objects Player(1</spa n>) Player(2</spa n>) glob.ball</spa n> = Ball() objects = (</s pan>glob.player1, glob.player2, glob</sp an>.ball) # Create rooms room1 = sge</s pan>.Room(objects, background =background ) sge.game.start() if __name__ ==</sp an> '__main__': main() </pre></div> </div> Since the graphics of Pong are so simple, we are dynamically generating them rather than loading existing images. We are also generating a background with a line in the middle by using a <a class="reference internal" href="BackgroundLayer.html#sge.BackgroundLayer" ti
tle="sge.BackgroundLayer"><tt class="xref py py-class docutils literal">sge.BackgroundLayer</tt></a> object. Background layers basicall y tell a background how to tile a particular sprite in order to decorate the background. In our case, we take the ball sprite (since it is just a white square; no need to create an entirely new one) and tile it only vertically in the horizontal center of the screen (vertically at y=0, but this doesn’t matter because the sprite is being tiled infinitely in the vertical direction). We set the game to run at 120 frames per second because it’s hard to play Pong with digital controls, and a higher frame rate helps minimize this difficulty. </div> <div class="section" id="pong-without-scoring-or-sound"> <h2>Pong Without Scoring or Sound<a class="headerlink" href="#pong-without-scori ng-or-sound" title="Permalink to this headline"></a></h2> This is what we have so far: <div class="highlight-python"><div class="highlight"><pre>#!/usr /bin/env python3 # Pong # Written in 2013 by Julian Marchant <onpon4@riseup.net> # # To the extent possible under law, the author(s) have dedicated all # copyright and related and neighboring rights to this software to the # public domain worldwide. This software is distributed without any # warranty. # # You should have received a copy of the CC0 Public Domain Dedic ation # along with this software. If not, see # <http://creativecommons.org/publicdomain/zero/1.0/>.</sp an> import sge PADDLE_SPEED = 4 PADDLE_VERTICAL_FORCE = 1 / 12 BALL_START_SPEED = 2 BALL_ACCELERATION = 0.2 BALL_MAX_SPEED = 15 class glob: # This class is for global variables. While not necessary, using a # container class like this is less potentially confusing th an using # actual global variables.
player1 = Non e player2 = Non e ball = None hud_sprite = None bounce_sound = None bounce_wall_sound = None score_sound = None game_in_progress = True class Game(sge.Game<s pan class="p">): def event_key_press(self, key, char): if key == 'f8': sge.Sp rite.from_screenshot().save('screenshot.jpg')</s pan> elif key = = 'escape': self. event_close() elif key in ('p', 'enter'): self. pause() def event_close(self): m = " Are you sure you want to quit?" if sge.</s pan>show_message(m , ("No ", "Yes"<spa n class="p">)): self. end() def event_paused_key_press<sp an class="p">(self, key, char):
if key == 'escape': # This allows the player to still exit while the gam e is # paused, rather than having to unpause first. self. event_close() else: self. unpause() def event_paused_close(self): # This allows the player to still exit while the game is paused, # rather than having to unpause first. self.even t_close() class Player(</sp an>sge.StellarClas s): def __init__( self, play er=1):</sp an> if player == 1: self. up_key = "w" self. down_key = "s" x = 3 2 glob.p layer1 = self self. hit_direction = 1 else: self. up_key = "up" self. down_key = "down" x = sg e.game.</sp an>width - 32</sp an> glob.p layer2 = self self. hit_direction = -1 y = sge</s pan>.game.height / 2 super().__init__(x, y, 0, sprite<s pan class="o">="paddle") def event_step(self, ti me_passed): # Movement key_motion = (sge.get _key_pressed(self.down_key) - sge.get_key_pressed(self</spa n>.up_key)) self.yvel ocity = key_motion * PADDLE_SPEED # Keep the paddle inside the window if self.bbox_top < 0: self. bbox_top = 0 elif self .bbox_bottom > sge.game.height: self. bbox_bottom = sge.game.height class Ball(sge.StellarClass): def __init__( self): x = sge</s pan>.game.width / 2 y = sge</s pan>.game.height / 2 super().__init__(x, y, 1, sprite<s pan class="o">="ball") def event_create(self):
self.serv e() def event_step(self, ti me_passed): # Scoring if self.bbox_right < 0: self. serve(-1) elif self .bbox_left > sge.game.width: self. serve(1) # Bouncing off of the edges if self.bbox_bottom > sge.game.height: self. bbox_bottom = sge.game.height self. yvelocity = -abs(self.yvelocity) elif self .bbox_top < 0: self. bbox_top = 0 self. yvelocity = abs(self.yvelocity) def event_collision(self, other): if isinstance(other, Player): if other.hit_direction == 1: self.bbox_left = other.bbox_right + <sp an class="mi">1 self.xvelocity = min(abs(self.xvelocity) + BALL_ACCELERATION</spa n>, BALL_MAX_SPEED) else: self.bbox_right = other.bbox_left - <sp an class="mi">1 self.xvelocity = max(-abs(self. xvelocity) - BALL_ACCELERATION, -BAL L_MAX_SPEED) self. yvelocity += (self.y - other.y) * PADDLE_VE RTICAL_FORCE def serve(</s pan>self, directi on=1):</sp an> self.x</s pan> = self.</spa n>xstart self.y</s pan> = self.</spa n>ystart # Next round self.xvel ocity = BALL_START_SPEED <s pan class="o">* direction self.yvel ocity = 0 def main(): # Create Game object Game(640</spa n>, 480, fps=120<spa n class="p">) # Load sprites paddle_sprite = sge.Sprite(ID=" paddle", width=8, height=48, origin_x=4, origin_y=24) paddle_sprite. draw_rectangle(0, 0, paddle_sprite.width, paddle_sprite.height, fill="white"<s pan class="p">) ball_sprite = sge.Sprite( ID="ba ll", width=8, he ight=8,</s pan> origin_x=4, origin_y=</s pan>4) ball_sprite.dr aw_rectangle(0, 0, b all_sprite.width, ball_sprite.height, fill=</spa n>"white") # Load backgrounds layers = (</sp an>sge.BackgroundL ayer("ball", sge.game.width / 2, 0, -10000 , xrepeat =False),) background = s ge.Background (layers, "black") # Create objects Player(1</spa n>) Player(2</spa n>) glob.ball</spa n> = Ball() objects = (</s pan>glob.player1, glob.player2, glob</sp an>.ball)
# Create rooms room1 = sge</s pan>.Room(objects, background =background ) sge.game.start() if __name__ ==</sp an> '__main__': main() </pre></div> </div> This is a playable Pong game; there are two paddles and a ball, and the ball returns any time it leaves the left or right side of the screen. Unfortunately, though, it is at this point less like Pong and more like the Magnavox Odyssey; there is no scoring, so you have to keep track of this manually, and there is no sound. Let’s fix those problems. </div> <div class="section" id="adding-scoring"> <h2>Adding Scoring<a class="headerlink" href="#adding-scoring" title="Permalink to this headline"></a></h2> It’s a little weird to have a video game that doesn’t keep score, so we will now add a proper scoring system to our Pong game. Each player will get one point whenever the ball passes by the other player, and whoever gets 10 points first will win. Let’s start by defining some constants: <div class="highlight-python"><div class="highlight"><pre>POINTS _TO_WIN = 10 TEXT_OFFSET = 16 </pre></div> </div> There are a couple of ways to display the score. The most obvious way is to project the score each frame, but we are instead going to create a custom sprite, an object to display that sprite, and re-draw to it as needed. While projection will work just fine for Pong, drawing to a sprite will be much easier than projections for more complicated HUDs, so it’s good to know how to do it. <div class="section" id="hud-sprite-and-object"> <h3>HUD sprite and object<a class="headerlink" href="#hud-sprite-and-object" tit le="Permalink to this headline"></a></h3> First, we need to create the HUD sprite and the HUD object. We will do this in the <tt class="xref py py-func docutils literal">main( )</tt> function. Add one more sprite to the list of sprites: <div class="highlight-python"><div class="highlight"><pre>glob.hud_sprite = sge.Sprite (width=</sp an>320, height</s pan>=160, origin_x=160</spa n>, origin_y=</s
pan>0) </pre></div> </div> Create a HUD object: <div class="highlight-python"><div class="highlight"><pre>hud</s pan> = sge. StellarClass(sge.game. width / 2, 0, -10, sprite=glob.hud_sprite, detects_collisions =False) </pre></div> </div> And finally, add the HUD object to the list of initial objects: <div class="highlight-python"><div class="highlight"><pre>object s = (glob.player1,</sp an> glob.player2, glob.ball, hud) </pre></div> </div> We want to put the HUD sprite in a globally-accessible variable because we are going to change the score table by changing the sprite directly. The HUD object, on the other hand, never needs to be changed; it just needs to be in the room. The size of the HUD sprite is arbitrary. Most of it is going to be invisible, so our only requirement for it is that it needs to be large enough to fit the rendered text. </div> <div class="section" id="font"> <h3>Font<a class="headerlink" href="#font" title="Permalink to this headline"></a> </h3> Next, we need to load a font. To do so, we will add this (I am putting it between the background and object creations, but you can put them anywhere in <tt class="xref py py-func docutils literal">main( )</tt> as long as it’s before the game is started): <div class="highlight-python"><div class="highlight"><pre># Load fonts sge.Font<sp an class="p">('Liberation Mono', ID=& quot;hud", size=48) </pre></div> </div> For the first argument of <a class="reference internal" href="Font.html#sge.F ont.__init__" title="sge.Font.__init__"><tt class="xref py py-meth docutils lite ral">sge.Font.__init__()</tt></a>, we specify one of two things: either the name of a system font, or the name of a font file that we are distributing with our game in our data folder. For simplicity, we will use a system font for now. I chose Liberation Mono, but you can choose any font you like. <div class="admonition note"> Note
What system fonts are available on a given system is not standar dized in any way. If you specify a system font and that system font is not available, the SGE will choose what font to use arbitrarily. For this reason, you should never use system fonts in your games except as a temporary placeholder. </div> </div> <div class="section" id="score-property"> <h3>Score property<a class="headerlink" href="#score-property" title="Permalink to this headline"></a></h3> Now let’s add score attributes to the players. Because we want to refresh the HUD every time the score changes, we are going to make these score attributes a property of the <tt class="xref py py-class docutils literal" >Player</tt> class: <div class="highlight-python"><div class="highlight"><pre>@prop erty def score( self): return self.v_score @score.setter def score( self, value): if value !=</s pan> self.v_score : self.v_sc ore = value refresh_hud() </pre></div> </div> <tt class="xref py py-func docutils literal">refresh_hud()</tt> will be the function we define later on to refresh the HUD. Next, we need to initialize <tt class="xref py py-attr docutils literal"><spa n class="pre">v_score</tt>. We will do this in the create event: <div class="highlight-python"><div class="highlight"><pre>def</s pan> event_create(self): self.v_score = 0 </pre></div> </div> The reason we initialize <tt class="xref py py-attr docutils literal">v_score</tt> directly is because <tt class="xref py py-func docutils literal">refresh_hud()</sp an></tt> is going to need both player’s scores; if we call it before both players’ scores are initialized, we will get an error. </div> <div class="section" id="refresh-hud-function"> <h3>Refresh HUD Function<a class="headerlink" href="#refresh-hud-function" title ="Permalink to this headline"></a></h3> Now that the score property is defined, let’s add that function: <div class="highlight-python"><div class="highlight"><pre>def</s pan> refresh_hud(): # This fixes the HUD sprite so that it displays the correct
score. glob.hud_sprit e.draw_clear() x = glob.hud_sprite.</spa n>width / 2 glob.hud_sprit e.draw_text ("hud", str(glob.player1.score), x - TEXT_OFFSET, TEXT_OFFSET , color=&qu ot;white", halign=</sp an>sge.ALIGN_RIGHT , valign=sge.ALIGN_TOP ) glob.hud_sprit e.draw_text ("hud", str(glob.player2.score), x + TEXT_OFFSET, TEXT_OFFSET , color=&qu ot;white", halign=</sp an>sge.ALIGN_LEFT, valign=</s pan>sge.ALIGN_TOP) </pre></div> </div> First we clear the sprite with <a class="reference internal" href="Sprite.htm l#sge.Sprite.draw_clear" title="sge.Sprite.draw_clear"><tt class="xref py py-met h docutils literal">sge.Sprite.draw_clear()</tt></a>, t hen we draw both player’s scores on it; player 1’s score goes on the left, and player 2’s score goes on the right. We use <tt class="xref py py-const do cutils literal">TEXT_OFFSET</tt> to make it look nicer; if you set <tt class="xref py py-const docutils literal">TEXT_OFFSET</tt> to <tt class="docutils literal">0</tt>, you will notice that it looks a little ugly because the text is right next to the line and right below the top of the screen. The way it is now, the score won’t start being displayed until someone scores, which is not what we want. To prevent this, we want to call <tt class="xref py py-func docutils literal">refresh_hud()</sp an></tt> somewhere when the game starts. I am choosing the create event of <tt class="xref py py-class docutils literal"> Ball</tt>, because the ball is created after both of the players (and so its create event will always execute after both of
the player objects’). </div> <div class="section" id="adding-points"> <h3>Adding Points<a class="headerlink" href="#adding-points" title="Permalink to this headline"></a></h3> We need to make the players actually get points for the scoring system to be of any use. This is what we currently have in the step event of <tt class="xref py py-class docutils literal">Ball</ tt>: <div class="highlight-python"><div class="highlight"><pre># Scor ing if self.<s pan class="n">bbox_right < 0: self.serve</s pan>(-1<sp an class="p">) elif self. bbox_left > sge .game.</spa n>width: self.serve</s pan>(1) </pre></div> </div> Let’s add some lines to increase the players’ score: <div class="highlight-python"><div class="highlight"><pre># Scor ing if self.<s pan class="n">bbox_right < 0: glob.player2.score +=</sp an> 1 self.serve</s pan>(-1<sp an class="p">) elif self. bbox_left > sge .game.</spa n>width: glob.player1.score +=</sp an> 1 self.serve</s pan>(1) </pre></div> </div> Now, every time the ball passes a player, the opposite player will get a point. </div> <div class="section" id="win-condition"> <h3>Win Condition<a class="headerlink" href="#win-condition" title="Permalink to this headline"></a></h3> At this point, the game will go on forever until the players decide to stop. That’s not what we want; we want the first player to get 10 points to be declared the winner. We will handle this in <tt class="xref py py-meth docutils literal">Ball.serve()</spa n></tt>. This is what we have so far: <div class="highlight-python"><div class="highlight"><pre>def</s
pan> serve(self, direction= 1): self.x = self.<s pan class="n">xstart self.y = self.<s pan class="n">ystart # Next round self.xvelocit y = BALL_START_SPEED * direction self.yvelocit y = 0 </pre></div> </div> Replace that with this: <div class="highlight-python"><div class="highlight"><pre>def</s pan> serve(self, direction= 1): self.x = self.<s pan class="n">xstart self.y = self.<s pan class="n">ystart if (glob.player1.score < POINTS_T O_WIN and glob.p layer2.score < POINTS_TO_WIN): # Next round self.xvel ocity = BALL_START_SPEED <s pan class="o">* direction self.yvel ocity = 0 else: # Game Over! self.xvel ocity = 0 self.yvel ocity = 0 glob.hud_s prite.draw_clear() x = glob.hud_sprite.width / 2 p1score = glob.player1.score p2score = 
glob.player2.score p1text = & quot;WIN" if p1score > p2score else "LOSE" p2text = & quot;WIN" if p2score > p1score else "LOSE" glob.hud_s prite.draw_text("hud", p1text, x - TEXT_OFFSET, TEXT_OFFSET, color="white", halign= sge.ALIGN_R IGHT, valign= sge.ALIGN_T OP) glob.hud_s prite.draw_text("hud", p2text, x + TEXT_OFFSET, TEXT_OFFSET, color="white", halign= sge.ALIGN_L EFT, valign= sge.ALIGN_T OP) glob.game_ in_progress = False </pre></div> </div> That’s a lot of extra code. First, we check if both players’ sco res are less than <tt class="xref py py-const docutils literal">POINTS _TO_WIN</tt>. If it is, that means the game is still in progress, so we start the next round as the function did previously. Otherwise, we stop the ball, and then we draw “WIN” on the winner’s side, and “LOSE” on the loser’s side. I used t wo conditional expressions to achieve this because it’s quick, and if by some freak accident (perhaps the result of a “2-balls mod” or something) both players get 10 points at the same time, it will be considered a loss for both players. We will also set <tt class="xref py py-attr docutils literal">glob.game_in_progress</tt> to False, so that it can be understood by other functions and methods that a game is not currently in progress. We will use this later to give the pause keys a secondary function of starting a new game.
</div> </div> <div class="section" id="adding-sound"> <h2>Adding Sound<a class="headerlink" href="#adding-sound" title="Permalink to t his headline"></a></h2> There are three sounds we want to add: one for when the ball hits a paddle, one for when the ball hits a wall, and one for when a player scores. There are many ways you can get these sounds. The easiest way is to find them on a website that has free/libre culture sound effects available. A good place to search for such assets is <a class="reference extern al" href="http://opengameart.org">OpenGameArt.org</a>. Another easy way if you only need simple sound effects, and the method I used, is to generate them with a free/libre program called <a class="reference external" href="http://www.drpette r.se/project_sfxr.html">sfxr</a>. Whatever method you use, once you have your three sound effects, set their file names to “bounce”, “bounce_wall”, and “score”, plus w hatever extension is appropriate. Make sure to use a format supported by the SGE implementation used; in my case, I can use WAV and Ogg Vorbis sound effects, and my sound files are all WAV format. Create a folder in the same location as pong.py called “data”. W ithin the “data” folder, create another folder called “sounds” . <div class="admonition note"> Note Directories are not case-sensitive on all file systems; most not ably, NTFS (the file system used by Windows) would treat the directory name “data” as being identical to “Data”. However, many other file systems are case-sensitive. On those file systems, “data” is distinct from “Data”. Because of this, don’t get into the hab it of capitalizing the names of these folders; it’s “data”, not &#82 20;Data”, and it’s “sounds”, not “Sounds”. </div> Put your three sound effects, which in my case are now named “bounce.wav”, “bounce_wall.wav”, and “score.wav&#8 221;, into data/sounds. <div class="section" id="loading-the-sounds"> <h3>Loading The Sounds<a class="headerlink" href="#loading-the-sounds" title="Pe rmalink to this headline"></a></h3> To use sound effects, we first need to load them. We will do so in the <tt class="xref py py-func docutils literal">main()</tt > function. I am putting this code after the code that loads the font and before the code that creates the objects: <div class="highlight-python"><div class="highlight"><pre># Load sounds glob.bounce_sound = sge.</spa n>Sound('bounc e.wav') glob.bounce_wall_s ound = sge. Sound(' bounce_wall.wav')
glob.score_sound = sge.Sound('score. wav') </pre></div> </div> </div> <div class="section" id="playing-the-sounds"> <h3>Playing The Sounds<a class="headerlink" href="#playing-the-sounds" title="Pe rmalink to this headline"></a></h3> This part is extremely simple. Just call <a class="reference internal" href= "Sound.html#sge.Sound.play" title="sge.Sound.play"><tt class="xref py py-meth do cutils literal">sge.Sound.play()</tt></a> in the proper places. Here: <div class="highlight-python"><div class="highlight"><pre># Scor ing if self.<s pan class="n">bbox_right < 0: glob.player2.score +=</sp an> 1 glob.score_sou nd.play() self.serve</s pan>(-1<sp an class="p">) elif self. bbox_left > sge .game.</spa n>width: glob.player1.score +=</sp an> 1 glob.score_sou nd.play() self.serve</s pan>(1) </pre></div> </div> Here: <div class="highlight-python"><div class="highlight"><pre># Boun cing off of the edges if self.<s pan class="n">bbox_bottom > sge .game.</spa n>height: self.bbox_bot tom = sge.game.height self.yvelocit y = -abs(self.yvelocity) glob.bounce_wa ll_sound.play() elif self. bbox_top < 0: self.bbox_top = 0 self.yvelocit y = abs(self.yveloci ty) glob.bounce_wa ll_sound.play() </pre></div> </div> And here: <div class="highlight-python"><div class="highlight"><pre>def</s pan> event_collision(self, other): if isinstance (other, Pla yer): if other.hit_direction == 1: self. bbox_left = other.bbox_right + 1 self. xvelocity = min(abs(self.xvelocity) + BALL_ACCELERATION<s pan class="p">, BALL_MAX_SPEED) else: self. bbox_right = other.bbox_left - 1 self. xvelocity = max(-abs (self.xvel ocity) - BA LL_ACCELERATION, -BALL_MA X_SPEED) self.yvel ocity += ( self.y -</s pan> other.y) * PADDLE_VERTIC AL_FORCE glob.bounc e_sound.play() </pre></div> </div> </div> </div> <div class="section" id="restarting-the-game"> <h2>Restarting The Game<a class="headerlink" href="#restarting-the-game" title=" Permalink to this headline"></a></h2> One last touch: we’re going to allow the game to be restarted. We do this by modifying the key press event for <a class="reference internal" href="Ga me.html#sge.Game" title="sge.Game"><tt class="xref py py-class docutils literal" >sge.Game</tt></a>, specifically the keys that normally pause the game: <div class="highlight-python"><pre>elif key in ('p', 'enter' ): if glob.game_in_progress: self.pause() else: glob.game_in_progress = True self.current_room.start()</pre> </div> If the game is in progress, we pause the game, as before. Otherwise, we set <tt class="xref py py-attr docutils literal">glob.game_in_ progres</tt> to <tt class="xref py py-const docutils literal">True</tt> and call the current room’s <tt class="xref py py-meth docutils literal">star t()</tt> method, which resets and starts the room. </div> <div class="section" id="the-final-result"> <h2>The Final Result<a class="headerlink" href="#the-final-result" title="Permal ink to this headline"></a></h2> Congratulations! You have completed your first real game. This is the final result: <div class="highlight-python"><div class="highlight"><pre>#!/usr /bin/env python3 # Pong # Written in 2013 by Julian Marchant <onpon4@riseup.net> # # To the extent possible under law, the author(s) have dedicated all # copyright and related and neighboring rights to this software to the # public domain worldwide. This software is distributed without any # warranty. # # You should have received a copy of the CC0 Public Domain Dedic ation # along with this software. If not, see # <http://creativecommons.org/publicdomain/zero/1.0/>.</sp an> import sge PADDLE_SPEED = 4 PADDLE_VERTICAL_FORCE = 1 / 12
BALL_START_SPEED = 2 BALL_ACCELERATION = 0.2 BALL_MAX_SPEED = 15 POINTS_TO_WIN = 1 0 TEXT_OFFSET = 16 class glob: # This class is for global variables. While not necessary, using a # container class like this is less potentially confusing th an using # actual global variables. player1 = Non e player2 = Non e ball = None hud_sprite = None bounce_sound = None bounce_wall_sound = None score_sound = None game_in_progress = True class Game(sge.Game<s pan class="p">): def event_key_press(self, key, char): if key == 'f8': sge.Sp rite.from_screenshot().save('screenshot.jpg')</s pan> elif key = = 'escape': self. event_close() elif key in ('p', 'enter'): if glob.game_in_progress: self.pause() else: glob.game_in_progress = True self.current_room.start() def event_close(self): m = " Are you sure you want to quit?" if sge.</s pan>show_message(m , ("No ", "Yes"<spa n class="p">)): self. end() def event_paused_key_press<sp an class="p">(self, key, char): if key == 'escape': # This allows the player to still exit while the gam e is # paused, rather than having to unpause first. self. event_close() else: self. unpause() def event_paused_close(self): # This allows the player to still exit while the game is paused, # rather than having to unpause first. self.even t_close() class Player(</sp an>sge.StellarClas s): @property def score(</s pan>self): return self.v_score @score.setter
def score(</s pan>self, value): if value ! = self.v_s core: self. v_score = value refresh_hud() def __init__( self, play er=1):</sp an> if player == 1: self. up_key = "w" self. down_key = "s" x = 3 2 glob.p layer1 = self self. hit_direction = 1 else: self. up_key = "up" self. down_key = "down" x = sg e.game.</sp an>width - 32</sp an> glob.p layer2 = self self. hit_direction = -1 y = sge</s pan>.game.height / 2 super().__init__(x, y, 0, sprite<s pan class="o">="paddle") def event_create(self): self.v_sc ore = 0 def event_step(self, ti me_passed): # Movement
key_motion = (sge.get _key_pressed(self.down_key) - sge.get_key_pressed(self</spa n>.up_key)) self.yvel ocity = key_motion * PADDLE_SPEED # Keep the paddle inside the window if self.bbox_top < 0: self. bbox_top = 0 elif self .bbox_bottom > sge.game.height: self. bbox_bottom = sge.game.height class Ball(sge.StellarClass): def __init__( self): x = sge</s pan>.game.width / 2 y = sge</s pan>.game.height / 2 super().__init__(x, y, 1, sprite<s pan class="o">="ball") def event_create(self): refresh_hud() self.serv e() def event_step(self, ti me_passed): # Scoring if self.bbox_right < 0: glob.p layer2.score += 1 glob.s core_sound.play() self. serve(-1) elif self .bbox_left > sge.game.width: glob.p layer1.score += 1 glob.s core_sound.play() self. serve(1) # Bouncing off of the edges if self.bbox_bottom > sge.game.height: self. bbox_bottom = sge.game.height self. yvelocity = -abs(self.yvelocity) glob.b ounce_wall_sound.play() elif self .bbox_top < 0: self. bbox_top = 0 self. yvelocity = abs(self.yvelocity) glob.b ounce_wall_sound.play() def event_collision(self, other): if isinstance(other, Player): if other.hit_direction == 1: self.bbox_left = other.bbox_right + <sp an class="mi">1 self.xvelocity = min(abs(self.xvelocity) + BALL_ACCELERATION</spa n>, BALL_MAX_SPEED) else: self.bbox_right = other.bbox_left - <sp an class="mi">1 self.xvelocity = max(-abs(self. xvelocity) - BALL_ACCELERATION, -BAL L_MAX_SPEED) self. yvelocity += (self.y - other.y) * PADDLE_VE RTICAL_FORCE glob.b ounce_sound.play() def serve(</s pan>self, directi on=1):</sp an> self.x</s pan> = self.</spa n>xstart self.y</s pan> = self.</spa n>ystart if (glob.player1.</sp an>score < POIN TS_TO_WIN and glob.player2.score < POINTS_TO_WIN): # Next round self. xvelocity = BALL_START_SPEED * direction
self. yvelocity = 0 else: # Game Over! self. xvelocity = 0 self. yvelocity = 0 glob.h ud_sprite.draw_clear() x = gl ob.hud_sprite.width / 2 p1score = glob.player1.score p2score = glob.player2.score p1text = "WIN" if p1score</spa n> > p2score el se "LOSE" p2text = "WIN" if p2score</spa n> > p1score el se "LOSE" glob.h ud_sprite.draw_text("hud", p1text, x <s pan class="o">- TEXT_OFFSET, TEXT_OFFSET, color="white", halign=sge.ALI GN_RIGHT, valign=sge.ALI GN_TOP) glob.h ud_sprite.draw_text("hud", p2text, x <s pan class="o">+ TEXT_OFFSET, TEXT_OFFSET, color="white", halign=sge.ALI GN_LEFT, valign=sge.ALI GN_TOP) glob.g
ame_in_progress = False def refresh_hud() : # This fixes the HUD sprite so that it displays the correct score. glob.hud_sprit e.draw_clear() x = glob.hud_sprite.</spa n>width / 2 glob.hud_sprit e.draw_text ("hud", str(glob.player1.score), x - TEXT_OFFSET, TEXT_OFFSET , color=&qu ot;white", halign=</sp an>sge.ALIGN_RIGHT , valign=sge.ALIGN_TOP ) glob.hud_sprit e.draw_text ("hud", str(glob.player2.score), x + TEXT_OFFSET, TEXT_OFFSET , color=&qu ot;white", halign=</sp an>sge.ALIGN_LEFT, valign=</s pan>sge.ALIGN_TOP) def main(): # Create Game object Game(640</spa n>, 480, fps=120<spa n class="p">) # Load sprites paddle_sprite = sge.Sprite(ID=" paddle", width=8, height=48, origin_x=4, origin_y=24) paddle_sprite. draw_rectangle(0, 0, paddle_sprite.width, paddle_sprite.height, fill="white"<s pan class="p">) ball_sprite = sge.Sprite( ID="ba ll", width=8, he ight=8,</s pan> origin_x=4, origin_y=</s pan>4) ball_sprite.dr aw_rectangle(0, 0, b all_sprite.width, ball_sprite.height, fill=</spa n>"white") glob.hud_sprit e = sge.</s pan>Sprite(width=320, height=160, origin_x=160, origin_y =0) # Load backgrounds layers = (</sp an>sge.BackgroundL ayer("ball", sge.game.width / 2, 0, -10000 , xrepeat =False),) background = s ge.Background (layers, "black") # Load fonts sge.Font('Liberation Mono', ID="hud", size<sp an class="o">=48) # Load sounds glob.bounce_so und = sge.Sound('b ounce.wav') glob.bounce_wa ll_sound = sge.Sound(& #39;bounce_wall.wav') glob.score_sou nd = sge.Sound('sc ore.wav') # Create objects Player(1</spa n>) Player(2</spa n>) glob.ball</spa n> = Ball() hud = sge</spa n>.StellarClass(sge.game</spa n>.width / 2, 0, -10, sprite=glob.hud_sprite, detects_collisions=False) objects = (</s pan>glob.player1, glob.player2, glob</sp an>.ball, hud) # Create rooms room1 = sge</s pan>.Room(objects, background =background ) sge.game.start() if __name__ ==</sp an> '__main__': main() </pre></div> </div>
</div> </div> </div> </div> </div> <div class="sphinxsidebar"> <div class="sphinxsidebarwrapper"> <a href="index.html"> <img class="logo" src="_static/sge_logo_alpha_black.png" alt="Logo "/> </a> <h3><a href="index.html">Table Of Contents</a></h3> <ul> <li><a class="reference internal" href="#">Second Example: Pong</a><ul> <li><a class="reference internal" href="#setting-up-the-project">Setting Up the Project</a></li> <li><a class="reference internal" href="#global-variables">Global Variables</a>< /li> <li><a class="reference internal" href="#the-game-class">The Game Class</a></li> <li><a class="reference internal" href="#the-player-class">The Player Class</a>< /li> <li><a class="reference internal" href="#the-ball-class">The Ball Class</a></li> <li><a class="reference internal" href="#the-main-function">The main Function</a ></li> <li><a class="reference internal" href="#pong-without-scoring-or-sound">Pong Wit hout Scoring or Sound</a></li> <li><a class="reference internal" href="#adding-scoring">Adding Scoring</a><ul> <li><a class="reference internal" href="#hud-sprite-and-object">HUD sprite and o bject</a></li> <li><a class="reference internal" href="#font">Font</a></li> <li><a class="reference internal" href="#score-property">Score property</a></li> <li><a class="reference internal" href="#refresh-hud-function">Refresh HUD Funct ion</a></li> <li><a class="reference internal" href="#adding-points">Adding Points</a></li> <li><a class="reference internal" href="#win-condition">Win Condition</a></li> </ul> </li> <li><a class="reference internal" href="#adding-sound">Adding Sound</a><ul> <li><a class="reference internal" href="#loading-the-sounds">Loading The Sounds< /a></li> <li><a class="reference internal" href="#playing-the-sounds">Playing The Sounds< /a></li> </ul> </li> <li><a class="reference internal" href="#restarting-the-game">Restarting The Gam e</a></li> <li><a class="reference internal" href="#the-final-result">The Final Result</a>< /li> </ul> </li> </ul> <h4>Previous topic</h4> <a href="hello_world.html" title="previous chapter">First Example: Hello, world!</a > <h4>Next topic</h4> <a href="globalvars.html"
title="next chapter">Global Variables and Constants</a> <h3>This Page</h3> <ul class="this-page-menu"> <li><a href="_sources/pong.txt" rel="nofollow">Show Source</a></li> </ul> <div id="searchbox" style="display: none"> <h3>Quick search</h3> <form class="search" action="search.html" method="get"> <input type="text" name="q" /> <input type="submit" value="Go" /> <input type="hidden" name="check_keywords" value="yes" /> <input type="hidden" name="area" value="default" /> </form> Enter search terms or a module, class or function name. </div> <script type="text/javascript">$('#searchbox').show(0);</script> </div> </div> <div class="clearer"></div> </div> <div class="related"> <h3>Navigation</h3> <ul> <li class="right" style="margin-right: 10px"> <a href="genindex.html" title="General Index" >index</a></li> <li class="right" > <a href="globalvars.html" title="Global Variables and Constants" >next</a> |</li> <li class="right" > <a href="hello_world.html" title="First Example: Hello, world!" >previous</a> |</li> <li><a href="index.html">The Pygame SGE 0.8.0 documentation</a> »< /li> </ul> </div> <div class="footer"> Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3. </div> </body> </html>

Pong

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pong

Uploaded by

Copyright:

Available Formats

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.

You might also like