Pong - eLua Wiki

Information

Runs on: EK-LM3S8962, EK-LM3S6965
eLua Libs Used: EK-LM3S89(...), disp
Description

A tribute to the classics, as well as an addictive way of spending your time, this examples proves without any doubt that you can write games with eLua. This variant of the well known "pong" games plays on the OLED display of your LM3S board, using the on-board switches to control your paddle. Hit the ball, collect or avoid the "bonuses", a keep on trying to beat that highscore The code is just complex enough to give you a fair idea about the possibilities of eLua.
Videos

Pictures

eLua Pong v1.0
Code

-------------------------------------------------------------------------------
--
--		eLua Pong Game
--
-- LED Lab @ PUC-Rio - 2009
--   Dado Sutter
--   Ives Negreiros
--   Ricardo Rosa
--   Pedro Bittencourt
--   Teo Benjamin
--

-- Initial Version by Dado Sutter, Fev 2009
--    This had only the ball bouncing on walls, paddle and paddle movement
--
-- Greatly enhanced by Teo Benjamin in Aug/Sep 2009, adding:
--    Score, resizeable paddles, levels/speeds, items
--
--
-------------------------------------------------------------------------------

local canvas = {}
-- canvas.x                     -- Horizontal display size
-- canvas.y                     -- Vertical display size

local paddle = {}
-- paddle.size                  -- Actual Paddle size = ( 6 * ( paddle.size + 1 ) ) + 2
-- paddle.max_size              -- Max paddle.size value -> Constant
-- paddle.min_size              -- Min paddle.size value -> Constant
-- paddle.y                            -- Paddle's Y position ( X position not needed, always 0 )

local ball = {}
-- ball.x                       -- Ball's X position
-- ball.y                       -- Ball's Y position -> starts at a random position
-- ball.dx                      -- Ball's X movement ( 1 = moving right; -1 = moving left )
-- ball.dy                      -- Ball's Y movement ( 1 = moving down; -1 = moving up )
-- ball.char                    -- The char that is printed for the ball -> Constant

local item = {}
-- item.x                       -- Item's X position
-- item.y                       -- Item's Y position ( fix for each item )
-- item.char                    -- This is the char that represents the item ( if false, there is no item )
-- item.all_chars                     -- A table that contains all the possibles item chars. Initialized by upload_items() function

-- Define all constants
local tmr_id = 1
paddle.max_size = 4
paddle.min_size = 0
ball.char = "*"
local delay_incr = 2000


-- Define all "global" variables as program local ones.
-- The values are initialized at the main loop.

local score                    -- Player's score
local dscore                   -- How many points for each paddle hit
local delay_time               -- This value is used for the main delay, to make the game speed faster or slower
local paddle_hits              -- Counts the number of hits on paddle
local highscore                -- Current Highscore

item.all_chars = {}
local pressed = {}             -- pressed[ button ] is true if the corresponding button was pressed, or nil if not

local kit = require( pd.board() )  -- This variable is used as a pin assignments for the specific board

local itemFunction = {
["L"] = function ()
    draw_paddle( paddle.y, 0, 0 )
    if paddle.size < paddle.max_size then
      paddle.size = paddle.size + 1
    end
    draw_paddle( paddle.y, 11, 0 )
  end,
["S"] = function ()
    draw_paddle( paddle.y, 0, 0 )
    if paddle.size > paddle.min_size then
      paddle.size = paddle.size - 1
    end
    draw_paddle( paddle.y, 11, 0 )
  end,

["?"] = function ()
    item.char = item.all_chars[ math.random( #item.all_chars ) ]
    use_item()
  end,

["*"] = function ()
  end,

["P"] = function ()
    score = score + dscore
  end,

["D"] = function ()
    score = score * 2
  end,

["Z"] = function ()
    lm3s.disp.print( tostring( score ), 111, 89, 0 )
    score = 0
  end,

["T"] = function ()
    lm3s.disp.print( ball.char, ball.x, ball.y, 0 )
    ball.y = math.random( 82 )
    lm3s.disp.print( ball.char, ball.x, ball.y, 15 )
  end,
["F"] = function()
    if delay_time >= 1000 then
      delay_time = delay_time - 1000
    end
  end,
}

-- Updates Y paddle position and draw it using the draw_paddle( ... ) function
function update_paddle_pos()
  if kit.btn_pressed( kit.BTN_UP ) then
    if ( paddle.y > 0 ) then
      paddle.y = paddle.y - 1
      draw_paddle( paddle.y, 11, -1 )
    else
      tmr.delay( 1, 1700 )
    end
  elseif kit.btn_pressed( kit.BTN_DOWN ) then
    if ( paddle.y + ( paddle.size*6 ) + 1 < 90 ) then
      paddle.y = paddle.y + 1
      draw_paddle( paddle.y, 11, 1 )
    else
      tmr.delay( 1, 1600 )
    end
  else
    draw_paddle( paddle.y, 11, 0 )
    tmr.delay( 1, 300 ) -- Maintain function processing time aprox the same
  end
end

-- Draw the paddle in the display. This function is used by update_paddle_pos() function
function draw_paddle( y, color, movement )
  if ( movement == 0 ) then
    for i = 0, paddle.size, 1 do
      lm3s.disp.print( "|", 0, y + ( i * 6 ),  color )
    end
  elseif ( movement > 0 ) then      -- Paddle moving Down
    if y < 8 then
      lm3s.disp.print( "|", 0, 0,  0 )
    else
      lm3s.disp.print( "|", 0, y - 8 , 0 )
    end
    for i = 0, paddle.size, 1 do
      lm3s.disp.print( "|", 0, y + ( i * 6 ),  color )
    end
  elseif ( movement < 0 ) then    -- Paddle moving Up
    lm3s.disp.print( "|", 0, y + ( ( paddle.size + 1 ) * 6 ) + 2 , 0 )
    for i = 0, paddle.size, 1 do
      lm3s.disp.print( "|", 0, y + ( i * 6 ),  color )
    end
  end
end

-- Updates the ( X, Y ) ball position and prints the corresponding char
function update_ball_pos()
  if( ( ball.x + 5 >= canvas.x ) or ( ball.x <= 4 ) ) then
    ball.dx = -ball.dx;
    if ball.dx == -1 and item.char == false then
      createItem()
    end
  end
  if( ( ball.y >= 90 - ball.dy ) or ( ball.y <= 1 - ball.dy ) ) then
    ball.dy = -ball.dy;
  end
  lm3s.disp.print( ball.char, ball.x, ball.y, 0 )
  ball.x, ball.y = ( ball.x + ball.dx ), ( ball.y + ball.dy );
  lm3s.disp.print( ball.char, ball.x, ball.y, 15 )
end


-- Draw the top wall and erase the last one. Used to move it
function draw_wall( x )
  for i = 0, canvas.y, 7 do                    -- Erase the wall
    lm3s.disp.print( "|", canvas.x + 1, i, 0 )
  end
  canvas.x = x
  for i = 0, canvas.y, 7 do                    -- Draw a new wall
    lm3s.disp.print( "|", canvas.x + 1, i, 6 )
  end
end

-- Item Functions
function createItem()
  item.char = item.all_chars[ math.random( #item.all_chars ) ]
  item.x = canvas.x - 10
  item.y = ball.y
end

-- Upload the itens from table itemFunction into the table item.all_chars
-- Must be used to initialize the items
function upload_items()
  for k,v in pairs( itemFunction ) do
    table.insert( item.all_chars, k )
  end
end

-- Updates the item X position
function update_item_pos()
  if item.char then
    if ( item.x <= 4 ) then
      if ( ( item.y + 8 < paddle.y ) or ( item.y > paddle.y + ( paddle.size * 6 ) + 8 ) ) == false then
        use_item()
      end
      lm3s.disp.print( item.char, item.x, item.y, 0 )
      item.char = false
      return
    end
    lm3s.disp.print( item.char, item.x, item.y, 0 )
    item.x = item.x - 2
    lm3s.disp.print( item.char, item.x, item.y, 10 )
  end
end

-- Uses the item's function
function use_item()
  itemFunction[ item.char ]()
end

-- Checks if a button was clicked ( pressed and released )
-- Returns true or false
function button_clicked( button )
  if kit.btn_pressed( button ) then
    pressed[ button ] = true
  else
    if pressed[ button ] then
      pressed[ button ] = nil
      return true
    end
    pressed[ button ] = nil
  end
  return false
end

------------ MAIN ------------
upload_items()
lm3s.disp.init( 1000000 )

tmr.start( tmr_id )
--menu()
math.randomseed( tmr.read( tmr_id ) )    -- If you use the menu function, the time will be used as a seed to the random function
--tmr.stop( tmr_id )

collectgarbage( "collect" )





---------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------
--                                                                                                     --
--                                        GAME START                                                   --
--                                                                                                     --
---------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------

repeat
  canvas.x = 124
  canvas.y = 97
  ball.x = 5
  ball.y = math.random( ( canvas.y - 8 ) / 2 ) + ( canvas.y / 4 )
  ball.dx = 1
  ball.dy = 1
  paddle.y = ball.y - 4
  item.x = 0
  item.y = 0
  score = 0
  dscore = 1
  item.char = false
  paddle.size = 2
  delay_time = 10000
  paddle_hits = 0

  lm3s.disp.clear()

  draw_wall( canvas.x )
  draw_paddle( paddle.y, 11, 0 )

  while ( true ) do
    for i = 0, 1 do
      update_paddle_pos()
    end
    tmr.delay ( 0, delay_time )
    update_ball_pos()
    update_item_pos()
    if ( ball.x <= 4 ) then
      if ( ( ball.y + 8 < paddle.y ) or ( ball.y > paddle.y + ( paddle.size * 6 ) + 8 ) ) then  -- If this is true, you lose
        break
    else                                                                     -- Else, you score
        score = score + dscore
        paddle_hits = paddle_hits + 1
      end
    end

    if button_clicked( kit.BTN_RIGHT ) and delay_time > 0 then   -- If the right button is clicked, increase the level
      delay_time = delay_time - delay_incr
      dscore = dscore + 1
    end
    if button_clicked( kit.BTN_LEFT ) and dscore > 0 then    -- If the left button is clicked, decrease the level
      delay_time = delay_time + delay_incr
      dscore = dscore - 1
    end

    if ( paddle_hits == 5 ) and canvas.x > 80 then  -- After 5 hits in a row, move the wall until canvas.x = 80
      paddle_hits = 0
      draw_wall( canvas.x - 5 )
    end
    lm3s.disp.print( tostring( dscore ), 118, 0, 6 )
    lm3s.disp.print( tostring( score ), 111, 89, 6 )
    collectgarbage( "collect" )
  end
-------------------------------------------
-- Game Over
-------------------------------------------
  if score >= ( highscore or 0 ) then
    highscore = score
  end
  lm3s.disp.clear()
  lm3s.disp.print( "Game Over :(", 30, 20, 11 )
  lm3s.disp.print( "Your score was "..tostring( score ), 15, 40, 11 )
  lm3s.disp.print( "Highscore: "..tostring( highscore ), 15, 50, 11 )
  lm3s.disp.print( "SELECT to restart", 6, 70, 11 )
  enough = true
  for i=1, 100000 do
    if kit.btn_pressed( kit.BTN_SELECT ) then
      enough = false
      break
    end
  end
until ( enough )

lm3s.disp.off()
Files

Download (ZIP)