LÖVE

Code: Select all

function findTargetBall()
	--table to store our potential balls
	local potentialTargets = {}
	--index for our table above
	local j = 1

	for i = 1, #ballList do
		if ballList[i].v > 0 then
			--store all the balls moving down in our table
			potentialTargets[j] = ballList[i]
			j = j + 1
		end
	end

	for i = 1, #potentialTargets do
		--store our potentialTargets Y so we don't change it
		local y = potentialTargets[i].y
			--compare the y to our paddles
			while  y <= paddleList[2].y do
				--as long as its not passed our paddle we add some velocity
				y = y + potentialTargets[i].v
				--and count the steps
				potentialTargets[i].stepsToPaddle = potentialTargets[i].stepsToPaddle + 1
			end
		--now we sort by the steps putting the smallest in the front
		table.sort(potentialTargets, function(a,b) return a.stepsToPaddle < b.stepsToPaddle end)
	end
	
	for i = 1, #ballList do
		if ballList[i] == potentialTargets[1] then
			ballList[i].isTarget = true
		else
			ballList[i].isTarget = false
		end
	end
	
end

Code: Select all

--AI movement
	for i = 1, #ballList do
		local x = paddleList[2].x + .5 * paddleList[2].w
		if ballList[i].isTarget then
			if ballList[i].x >= x then
				--if its further than 5
				if ballList[i].x - x >= 5 then
					paddleList[2]:update(4.5) --Our max ball speed is 5, we want to be able to beat it
				else
					paddleList[2]:update(ballList[i].x - x)
				end
			elseif ballList[i].x < x then
				--if its further than 5
				if ballList[i].x - x >= -5 then
					paddleList[2]:update(-4.5)
				else
					paddleList[2]:update(ballList[i].x - x)
				end
			end
		end
	end

Code: Select all

if ballList[i].x - x >= -5 then
	paddleList[2]:update(-4.5)
else
	paddleList[2]:update(ballList[i].x - x)
end

Code: Select all

(height of my window - ball y)/ball velocity

Code: Select all

function findOptimal()

	local target
	local minSteps=math.huge

	for _,b in ipairs(ballList) do
		if b.v > 0 then
			local steps = (height - b.y)/b.v
			if steps < minSteps then
				minSteps=steps
				target=b
			end
		end
	end

	local xobj
	if target then
		xobj = target.x
	else
		xobj = love.graphics.getWidth()/2
	end
	local xdelta = xobj - paddleList[2].x - paddleList[2].w/2
	if xdelta < -4 then xdelta = -4 end
	if xdelta > 4 then xdelta = 4 end
	paddleList[2]:update(xdelta)
end

Code: Select all

function findOptimal()
 for i = 1, #potentialTargets do
  --count steps until the ball hits the paddle
  potentialTargets[i].stepsToPaddle = (paddleList[2].y - potentialTargets[i].r - potentialTargets[i].y)/potentialTargets[i].v
 end
 --sort the table now and put the shortest stepsToPaddle in the front
 table.sort(potentialTargets, function (a,b) return a.stepsToPaddle < b.stepsToPaddle end )

  --flag the ball that is our target
  targetX = love.graphics.getWidth() / 2
  if #potentialTargets > 0 then
    --predict the X coordinate where the ball will hit the paddle
    local destination = potentialTargets[1].x + potentialTargets[1].stepsToPaddle * potentialTargets[1].h
    local boundLeft = potentialTargets[1].r
    local boundRight = width - potentialTargets[1].r
    local fieldWidth = boundRight - boundLeft
    local offset = (destination - boundLeft) % fieldWidth
    local cycles = (destination - boundLeft - offset) / fieldWidth
    if cycles % 2 == 0 then
      targetX = offset + boundLeft
    else
      targetX = boundRight - offset
    end
  end
  targetX = targetX - paddleList[2].w / 2

  --using targetX-4 prevents oscillating around the target position
  if paddleList[2].x < targetX - 4 then
    paddleList[2]:update(4)
  elseif paddleList[2].x > targetX then
    paddleList[2]:update(-4)
  end
end