Pong game built on a minimal entity component system

Question

This simple game is built on the ECS described here: Minimal entity component system, take 2

local ecs = require 'ecs'
local ui = require 'ui'
local entities = {}
local velocitySystem = ecs.createSystem(
 { 'position', 'velocity' },
 function (entity, pos, vel)
 pos.x = pos.x + vel.vx
 pos.y = pos.y + vel.vy
 end)
local rectangleRenderingSystem = ecs.createSystem(
 { 'position', 'rectangle' },
 function (entity, pos, rect)
 ui.drawRect(pos, rect)
 end)
local aiSystem = ecs.createSystem(
 { 'position', 'speed', 'ai' },
 function (entity, pos, speed)
 local closestBallPos
 for target, posB in ecs.each(entities, { 'position', 'ball' }) do
 if (not closestBallPos) or (posB.x > closestBallPos.x) then
 closestBallPos = posB
 end
 end
 pos.y = pos.y + (closestBallPos.y - pos.y) * speed
 end)
local inputSystem = ecs.createSystem(
 { 'position', 'player' },
 function (entity, pos)
 pos.y = ui.mouseY or 0
 end)
local outOfBoundsSystem = ecs.createSystem(
 { 'position', 'rectangle', 'velocity', 'ball' },
 function (entity, pos, rect, vel)
 if pos.x <= 0 then
 print('Right player scored')
 pos.x = 50
 elseif pos.x >= 100 then
 print('Left player scored')
 pos.x = 50
 end
 end)
local bounceSystem = ecs.createSystem(
 { 'position', 'rectangle', 'velocity', 'ball' },
 function (entity, pos, rect, vel)
 if pos.y <= 0 or pos.y >= 100 then
 vel.vy = vel.vy * -1
 end
 end)
local function checkCollision(posA, rectA, posB, rectB)
 local halfHeightA, halfHeightB = rectA.h / 2, rectB.h / 2
 local halfWidthA, halfWidthB = rectA.w / 2, rectB.w / 2
 if (posA.y + halfHeightA <= posB.y - halfHeightB) or 
 (posA.y - halfHeightA >= posB.y + halfHeightB) or
 (posA.x + halfWidthA <= posB.x - halfWidthB) or 
 (posA.x - halfWidthA >= posB.x + halfWidthB) then
 return false
 end
 return true
end
local collisionSystem = ecs.createSystem(
 { 'collidable', 'position', 'rectangle', 'velocity' },
 function (entity, col, pos, rect, vel)
 for target, posB, rectB in ecs.each(entities,
 { 'position', 'rectangle', 'solid' }) do
 if entity == target then next() end
 if checkCollision(pos, rect, posB, rectB) then
 vel.vx = vel.vx * -1
 vel.vy = vel.vy * -1
 end
 end
 end)
local ball = {
 ball = true,
 collidable = true,
 position = { x = 50, y = 33 },
 velocity = { vx = 1, vy = 1 },
 rectangle = { w = 2, h = 2 },
}
local leftPaddle = {
 player = true,
 solid = true,
 position = { x = 0, y = 50 },
 rectangle = { w = 4, h = 10 },
}
local rightPaddle = {
 ai = true,
 solid = true,
 speed = 0.5,
 position = { x = 100, y = 50 },
 rectangle = { w = 4, h = 10 },
}
table.insert(entities, ball)
table.insert(entities, leftPaddle)
table.insert(entities, rightPaddle)
ui.loop(function ()
 velocitySystem(entities)
 rectangleRenderingSystem(entities)
 aiSystem(entities)
 inputSystem(entities)
 outOfBoundsSystem(entities)
 bounceSystem(entities)
 collisionSystem(entities)
end)

I'm wondering if I have the right idea about how I should be using an ECS. If there are problems with the ECS itself, please address it in linked question rather than here.

The "ui" script that's required at the top is some uninteresting OpenGL/GLUT stuff using luaglut. I can post it if necessary, but it should be pretty clear what it's doing.

I realize there are lots of magic numbers. I don't care, it's just a throwaway project to make sure the ECS is doing its job. All of the coordinates and measurements are in percents, so just pretend I made constants named FIFTY_PERCENT and so on.