Gravity Pong: A Pong game in ClojureScript using core.async
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
Abhinav Sarkar 5500f0bf94 Added readme il y a 9 ans
resources/public Added works only in chrome disclamer il y a 9 ans
src Removed earmuffs from the global variables il y a 9 ans
.gitignore added out and repl to gitignore il y a 9 ans Added readme il y a 9 ans
project.clj Got positioner and collision-detector working il y a 9 ans

Gravity Pong

Gravity Pong is the famous Pong game with a twist, written in ClojureScript using the core.async library. It can be played here (only works on Google Chrome for now).

Along with the usual Pong ball and the paddles on both sides of the screen, there is also a mass at the center of the screen which exerts a gravitational force on the ball causing it to change its path from a usual straight line to a curve. And the user can control the gravitational force using the keyboard to shape the ball's path as they want.

Details for Programmers

It is written in the Flow-based Programming paradigm where calculations of ball's position, velocity etc are done by separate modular components running in their own threads of computation (in this case, core.async go processes). These components are connected using signals (implemented using core.async channels) to form a network - like an electronic circuit - to build the complete game. The signals have values which change over time. window.requestAnimationFrame is used as a clock to generate the time ticks to run the game.

The very loose coupling (data coupling) caused by the modular design allows one to add new components in the network without changing other parts of it. In fact, this was first developed as a usual Pong game and gravitation was added only as an afterthought, with very minimal changes to the existing code.

Here is how the network of components interconnected with signals looks like:

                                      v             |                          |
 keyboard +-e-> sampler +---k---> paddle-postnr +-d-+   +-> gravitation +--+   |
                  ^                                 |   p                  a   |
                  t                                 |   |                  |   |
                  |                                 |   |                  |   |
                  +-------+          +-p----------+-|---+                  |   d
                          |          |  +-a-------|-|------+---------------+   |
                          |          v  v         | |      |                   v
  browser +-b--> ticker +-+--t--> ball-postnr +-p-+-|------|------------p-> renderer
                    ^     |             ^         | |      |                  ^  ^
                    |     |       +-----|---------+ |      |                  |  |
                    s     |       |     l     +--d--+      |                  s  t
                    |     |       |   +-+-----|-------+    |                  |  |
                    |     |       p   l   +-a-|-------|----+                  |  |
                    |     |       v   v   v   v  +-l--+                       |  |
                    |     +---t-> collision-detr                              |  |
                    |     |             ^        +-s--+-----------------------+  |
                    |     |             s             |                          |
                    +-----|-------------+-------------+                          |
                          |                                                      |


  • b: ticks from browser
  • t: game ticks
  • e: keyboard events
  • k: keydowns
  • p: ball position
  • l: ball velocity
  • a: ball acceleration
  • d: paddle positions
  • s: game state


  • keyboard: keyboard for user input
  • browser: browser as the primary source of ticks
  • ticker: generates game ticks from browser ticks
  • sampler: samples input signal based on a sampling signal
  • paddle-postnr: paddle positioner, calculates the position of paddles
  • ball-postnr: ball positioner, calculates the position of the ball
  • collision-detr: collision detector, detects collision of the ball with the paddles and the walls, also calculates the velocity of the ball
  • gravitation: calculates the acceleration of the ball due to gravitation
  • renderer: renders the game on screen

This project has been written as an experiment to play with the core.async library and can serve as a medium sized example project for the same. The main source can be found here.