LÖVE

Code: Select all

if self.ball.x + 2 < brick.x and self.ball.dx > 0 then

 -- flip x velocity and reset position outside of brick
self.ball.dx = -self.ball.dx
self.ball.x = brick.x - 8

Code: Select all

for i= 1 ,no_of_balls do

Code: Select all

if self.ballList[i] + 2 < brick.x and self.ballList[i+3] > 0 then  ....

Code: Select all

self.ballList = {}
table.update (self.ballList, self.ball.x, self.ball.y, self.ball.dx, self.ball2.x, self.ball2.y, self.ball2.dx)

Code: Select all

function PlayState:enter(params)
self.ball = params.ball

Code: Select all

local ball = {}
ball.x = 0
-- To declare a function value belonging to the ball table you can do:
ball.move = function(b) b.x = b.x + 10 end 
-- or 
function ball.move(b) b.x = b.x + 10 end
-- or
function ball.move(self) self.x = self.x + 10 end
-- or
function ball:move() self.x = self.x + 10 end -- here ':' is syntactic sugar that pass an argument called 'self' as the first argument

-- to call the move.ball function with the ball as parameter you can do :
ball.move(ball) 
-- or
ball:move() -- here ':' is syntactic sugar that pass the table containing the function as the first argument of the function

Code: Select all

Playstate.ball = {}
Playstate.bricks = {}
Playstate.walls= {}

function Playstate:new()
	for i = 0, x do 
		local brick = {}
		table.insert(self.bricks, brick)
	end
end

function Playstate:update(dt)
	-- collision code
	for k, brick in self.bricks do 
		if self.ball collide with brick then 
			remove brick and change self.ball direction
		 end
	end
	for k, wall in self.walls do 
		if self.ball collide with wall then 
			change self.ball direction
		 end
	end
end

Code: Select all

Playstate.balls = {}
Playstate.bricks = {}

function Playstate:new()
	for i = 0, x do 
		local brick = {}
		table.insert(self.bricks, brick)
	end
	local ball = {}
	table.insert(balls, ball)
end

function Playstate:update(dt)

	for k, ball in pairs(self.balls) do 
		for k,brick in pairs(self.bricks) do 
			if ball collide with brick then 
				remove brick and change ball direction
			 end
		end
		for k, wall in pairs(self.walls) do 
			if ball collide with wall then 
				change sball direction
			 end
		end
	end
	
end

Code: Select all

-- Your paddle
-- Using tables to store more complicated data structures (only option in lua, really)
local paddle = {
	-- your choice whether x and y represent the top-left corner of the paddle, or the center
	-- i"ll go with center
	x          = 0,
	y          = 0,
	length     = 0,
	multiplier = 1.0
}

-- The list of balls you can have
local balls = {}

-- This function creates one ball at a given coordinate
function newBall(x, y, s, a, z)
	-- Create a new instance
	local ball = {
		-- something or default is a shorthand you can use in lua to make something optional and give a default value
		-- again, your choice whether x and y represent the top-left corner of the paddle, or the center
		-- since this is a perfect circle, i'd go with the center
		x     = x or 0,
		y     = y or 0,
		speed = s or 0,
		angle = a or 0,
		size  = z or 0,
	}
	-- Since we're keeping tabs on all balls, instead of returning it, we put it at the end of our balls table.
	table.insert(balls, ball) -- balls[#balls+1] = ball would have worked as well, # returns the number of elements in a sequential table.
end

-- Two Power-ups

-- This applies the enlarge-paddle powerup, doubling its size
function enlargePaddle()
	-- Let's say that 4x is the largest you can make your paddle, so this can be applied, at most, twice.
	if paddle.multiplier < 4.0 then
		paddle.multiplier = paddle.multiplier * 2.0
	end
end

-- This applies the multi-ball powerup, duplicating ALL balls in play
function multiBall()
	-- We need to loop through the list of balls we have currently
	-- This code will put new balls at the end of the list, but the loop will stop at the last original ball, due to
	-- us using an explicit numeric loop.
	for i = 1, #balls do
		-- Let's create a few temporary variables to manipulate
		-- We can assign to all of these at once, lua allows that
		local x, y, angle = balls[i].x, balls[i].y, balls[i].angle
		-- Let's modify the angle of the ball, only on the horizontal axis... this takes some trigonometrical knowledge
		--angle = math.pi - angle
		angle = math.atan2(math.sin(angle), -math.cos(angle))
		-- Create a temporary variable to store the new ball's data.
		local ball = newBall(x, y, balls[i].speed, angle, balls[i].size)
		-- Add it to the end of the list
		table.insert(balls, ball)
	end
end

-- Input - I'm using the mousemoved callback, because it makes most sense.
function love.mousemoved(x, y, dx, dy)
	-- Simplest solution, tie the paddle's horizontal position to the mouse's, this works out since the paddle's position is
	-- the center of it
	paddle.x = x
	-- Let's prevent it from going out of bounds though
	-- Also, let's define a neat helper so we don't need to type that much
	local halflength = (paddle.length * paddle.multiplier / 2)
	if paddle.x - halflength < 0 then
		-- went off to the left
		paddle.x = 0 + halflength
	elseif paddle.x + halflength > love.graphics.getWidth() then
		-- went off to the right
		paddle.x = love.graphics.getWidth() - halflength
	end
end

-- Logic, keeping things simple, just updating all the balls and minimal collision detection with the corners of the window,
-- the balls themselves don't collide with each other.
function love.update(dt)
	-- Iterate over all balls, and apply the speed and angle to their positions
	for i, v in ipairs(balls) do
		-- This is a neat iterator loop, gives you back the object itself in the v variable
		-- Let's calculate how much we need to modify the coordinates of the current ball
		-- Again, trigonometry knowledge, or a quick google search on converting between cartesian and polar coordinates
		local dx = v.speed * math.cos(v.angle)
		local dy = v.speed * math.sin(v.angle)
		-- Apply the difference (delta); we also multiply with delta-time so that the movement is framerate-independent
		v.x = v.x + dx * dt
		v.y = v.y + dy * dt
		-- Check boundaries; lower-boundary erases the ball
		local radius = v.size / 2
		-- Not a completely correct implementation, but it works
		if v.x - radius < 0 then
			v.x = 0 + radius
			v.angle = math.atan2(math.sin(v.angle), -math.cos(v.angle))
		elseif v.x + radius > love.graphics.getWidth() then
			v.x = love.graphics.getWidth() - v.size / 2
			v.angle = math.atan2(math.sin(v.angle), -math.cos(v.angle))
		end
		-- Same for the other axis
		if v.y - radius < 0 then
			v.y = 0 + radius
			v.angle = math.atan2(-math.sin(v.angle), math.cos(v.angle))
		elseif v.y - radius > love.graphics.getHeight() then
			-- This is different, we want to remove the ball
			-- However, due to how iteration works, we need to do the removal after
			-- all balls have been processed... alternatively we could have iterated backwards,
			-- that would have worked... so, a hack is needed this way, let's define a field:
			v.deleteme = true
		end

		-- Check collision between ball and paddle
		local halflength = (paddle.length * paddle.multiplier / 2)
		-- Here, we need to adjust the angle based on where the ball hit the paddle
		-- so if ball's edges are horizontally inside the paddle's length, and if the ball is in the paddle,
		-- or went through it, we register a hit.
		if v.x - radius > paddle.x - halflength and v.x + radius < paddle.x + halflength and
			v.y + radius > paddle.y - 5 then
			-- Create the new angle for the ball, also modify its speed
			-- We map the horizontal angle relative to the paddle like so: [-1 .. 0 .. 1]
			local normal = (v.x - paddle.x) / (halflength) -- should result in a range of [-1,1] exactly, that we need
			v.angle = math.atan2(-math.sin(v.angle), normal)
			-- let's speed up the ball near the edges; we can reuse the normal we calculated above,
			-- although we don't care about the direction in this case, so we take the absolute value, or magnitude
			v.speed = v.speed * (math.abs(normal) /2 +.5)
			-- [0,1] -> [0,.5] -> [1,1.5] so the edges boost speed by 50%, and the center stays at 100% speed.
		end

	end
	-- Due to our hack, another loop, and we use table.remove to remove balls that need to be deleted;
	-- table.remove reorders the table so it fills the gaps, which we need.
	for i=#balls, 1, -1 do
		if balls[i].deleteme then
			table.remove(balls, i)
		end
	end

	-- If there are no more balls in play, spawn a new one (also, probably reset score and stuff)
	if #balls == 0 then
		local angle = math.atan2(-love.math.random(), love.math.random()*2-1)
		newBall(paddle.x, paddle.y - 20, 200, angle, 5)
	end
end

-- Draw out the elements
function love.draw()
	local halflength = (paddle.length * paddle.multiplier / 2)
	love.graphics.rectangle('fill', paddle.x - halflength, paddle.y - 5, halflength*2, 10)

	for i,v in ipairs(balls) do
		love.graphics.circle('fill', v.x, v.y, v.size)
		-- Debug stuff
		--love.graphics.arc('line',paddle.x,paddle.y,paddle.length*paddle.multiplier,v.angle,math.atan2(-math.sin(v.angle), (v.x - paddle.x) / (halflength * 2)))
		--love.graphics.arc('fill',v.x,v.y,v.speed*10,v.angle+0.01,v.angle-0.01)
		--love.graphics.print('speed' .. v.speed, 0, 36)
		--love.graphics.print('angle' .. v.angle, 0, 48)
		--love.graphics.print('normal' .. (v.x - paddle.x) / (halflength * 2), 0, 60)
	end

	-- Debug stuff
	--love.graphics.print(paddle.x, 0, 0)
	--love.graphics.print(paddle.y, 0, 12)
	--love.graphics.print(paddle.length, 0, 24)
end

-- Initialize the game
function love.load()
	-- Paddle's a global, so it's already there, but we can initialize its position here, since it's full of zeroes.
	paddle.x = love.graphics.getWidth() / 2
	paddle.y = love.graphics.getHeight() - 10
	paddle.length = 50
	-- We need to create a ball though: with 100 pixels/second going in a random direction but upwards, and with a size of 5
	local angle = math.atan2(-love.math.random(), love.math.random()*2-1)
	newBall(paddle.x, paddle.y - 20, 200, angle, 5)
end

-- Testing powerups, press l for making paddle larger, press m for multiball
function love.keypressed(k)
	if k == 'l' then
		enlargePaddle()
	elseif k == 'm' then
		multiBall()
	end
end