mirror of
https://github.com/love2d/love.git
synced 2026-08-12 00:20:52 +02:00
ell
825e46621e
- added physics.Contact, physics.Body, and physics.Shape obj tests - added graphics.Mesh and graphics.ParticleSystem obj tests - fixed some rgba tolerance needed on a couple methods - added test conclusion to zip artifact name for quick checking on PRs - ignored testsuite on compat mode windows builds
686 lines
30 KiB
Lua
686 lines
30 KiB
Lua
-- love.physics
|
|
|
|
|
|
--------------------------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
----------------------------------OBJECTS---------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
|
|
|
|
-- Body (love.physics.newBody)
|
|
love.test.physics.Body = function(test)
|
|
-- create body
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 0, 0, 'static')
|
|
local body2 = love.physics.newBody(world, 30, 30, 'dynamic')
|
|
love.physics.newRectangleShape(body1, 5, 5, 10, 10)
|
|
love.physics.newRectangleShape(body2, 5, 5, 10, 10)
|
|
test:assertObject(body1)
|
|
-- check state properties
|
|
test:assertEquals(true, body1:isActive(), 'check active by def')
|
|
test:assertEquals(false, body1:isBullet(), 'check not bullet by def')
|
|
body1:setBullet(true)
|
|
test:assertEquals(true, body1:isBullet(), 'check set bullet')
|
|
test:assertEquals(false, body1:isFixedRotation(), 'check fix rot def')
|
|
body1:setFixedRotation(true)
|
|
test:assertEquals(true, body1:isFixedRotation(), 'check set fix rot')
|
|
test:assertEquals(true, body1:isSleepingAllowed(), 'check sleep def')
|
|
body1:setSleepingAllowed(false)
|
|
test:assertEquals(false, body1:isSleepingAllowed(), 'check set sleep')
|
|
body1:setSleepingAllowed(true)
|
|
world:update(1)
|
|
test:assertEquals(false, body1:isAwake(), 'check fell asleep')
|
|
body1:setSleepingAllowed(false)
|
|
body1:setType('dynamic')
|
|
test:assertEquals(true, body1:isAwake(), 'check waking up')
|
|
test:assertEquals(false, body1:isTouching(body2))
|
|
body2:setPosition(5, 5)
|
|
world:update(1)
|
|
test:assertEquals(true, body1:isTouching(body2))
|
|
-- check body properties
|
|
test:assertEquals(1, #body1:getContacts(), 'check contact list')
|
|
test:assertEquals(0, #body1:getJoints(), 'check joints list')
|
|
love.physics.newDistanceJoint(body1, body2, 5, 5, 10, 10, true)
|
|
test:assertEquals(1, #body1:getJoints(), 'check joints list')
|
|
local x, y = body1:getLocalCenter()
|
|
test:assertEquals(5, math.floor(x), 'check local center x')
|
|
test:assertEquals(5, math.floor(y), 'check local center y')
|
|
local lx, ly = body1:getLocalPoint(10, 10)
|
|
test:assertEquals(10, math.floor(lx), 'check local point x')
|
|
test:assertEquals(9, math.floor(ly), 'check local point y')
|
|
local lx1, ly1, lx2, ly2 = body1:getLocalPoints(0, 5, 5, 10)
|
|
test:assertEquals(0, math.floor(lx1), 'check local points x 1')
|
|
test:assertEquals(4, math.floor(ly1), 'check local points y 1')
|
|
test:assertEquals(5, math.floor(lx2), 'check local points x 2')
|
|
test:assertEquals(9, math.floor(ly2), 'check local points y 2')
|
|
local wx, wy = body1:getWorldPoint(10.4, 9)
|
|
test:assertEquals(10, math.floor(wx), 'check world point x')
|
|
test:assertEquals(10, math.floor(wy), 'check world point y')
|
|
local wx1, wy1, wx2, wy2 = body1:getWorldPoints(0.4, 4, 5.4, 9)
|
|
test:assertEquals(0, math.floor(wx1), 'check world points x 1')
|
|
test:assertEquals(5, math.floor(wy1), 'check world points y 1')
|
|
test:assertEquals(5, math.floor(wx2), 'check world points x 2')
|
|
test:assertEquals(10, math.floor(wy2), 'check world points y 2')
|
|
test:assertEquals(0, body1:getAngularDamping(), 'check angular damping')
|
|
test:assertEquals(0, body1:getAngularVelocity(), 'check angular velocity')
|
|
test:assertObject(body1:getWorld())
|
|
test:assertEquals(2, body1:getWorld():getBodyCount(), 'check world count')
|
|
local cx, cy = body1:getWorldCenter()
|
|
test:assertEquals(46, math.floor(cx*10), 'check world center x')
|
|
test:assertEquals(60, math.floor(cy*10), 'check world center y')
|
|
local vx, vy = body1:getWorldVector(5, 10)
|
|
test:assertEquals(5, vx, 'check vector x')
|
|
test:assertEquals(10, vy, 'check vector y')
|
|
test:assertEquals(555, math.floor(body1:getInertia()*100), 'check inertia')
|
|
-- check get/set properties
|
|
test:assertEquals(0, body1:getAngle(), 'check def angle')
|
|
body1:setAngle(90 * (math.pi/180))
|
|
test:assertEquals(math.floor(math.pi/2*100), math.floor(body1:getAngle()*100), 'check set angle')
|
|
test:assertEquals(1, body1:getGravityScale(), 'check def grav')
|
|
body1:setGravityScale(2)
|
|
test:assertEquals(2, body1:getGravityScale(), 'check change grav')
|
|
test:assertEquals(0, body1:getLinearDamping(), 'check def lin damping')
|
|
body1:setLinearDamping(0.1)
|
|
test:assertEquals(1, math.floor(body1:getLinearDamping()*10), 'check change lin damping')
|
|
x, y = body1:getLinearVelocity()
|
|
test:assertEquals(1, x, 'check def lin velocity x')
|
|
test:assertEquals(1, y, 'check def lin velocity y')
|
|
body1:setLinearVelocity(4, 5)
|
|
x, y = body1:getLinearVelocity()
|
|
test:assertEquals(4, x, 'check change lin velocity x')
|
|
test:assertEquals(5, y, 'check change lin velocity y')
|
|
test:assertEquals(1, math.floor(body1:getMass()*10), 'check def mass')
|
|
body1:setMass(10)
|
|
test:assertEquals(10, body1:getMass(), 'check change mass')
|
|
body1:setMassData(3, 5, 10, 1)
|
|
local x, y, mass, inertia = body1:getMassData()
|
|
test:assertEquals(3, x, 'check mass data change x')
|
|
test:assertEquals(5, y, 'check mass data change y')
|
|
test:assertEquals(10, mass, 'check mass data change mass')
|
|
test:assertEquals(340, math.floor(inertia), 'check mass data change inertia')
|
|
body1:resetMassData()
|
|
x, y, mass, inertia = body1:getMassData()
|
|
test:assertEquals(5, math.floor(x), 'check mass data reset x')
|
|
test:assertEquals(5, math.floor(y), 'check mass data reset y')
|
|
test:assertEquals(1, math.floor(mass*10), 'check mass data reset mass')
|
|
test:assertEquals(5, math.floor(inertia), 'check mass data reset inertia')
|
|
x, y = body1:getPosition()
|
|
test:assertEquals(-1, math.floor(x), 'check position x')
|
|
test:assertEquals(0, math.floor(y), 'check position y')
|
|
body1:setPosition(10, 4)
|
|
x, y = body1:getPosition()
|
|
test:assertEquals(10, math.floor(x), 'check set position x')
|
|
test:assertEquals(4, math.floor(y), 'check set position y')
|
|
test:assertEquals('dynamic', body1:getType(), 'check type match')
|
|
body1:setType('kinematic')
|
|
body1:setType('static')
|
|
test:assertEquals('static', body1:getType(), 'check type change')
|
|
test:assertEquals(nil, body1:getUserData(), 'check user data')
|
|
body1:setUserData({ love = 'cool' })
|
|
test:assertEquals('cool', body1:getUserData().love, 'check set user data')
|
|
test:assertEquals(10, body1:getX(), 'check get x')
|
|
test:assertEquals(4, body1:getY(), 'check get y')
|
|
body1:setX(0)
|
|
body1:setY(0)
|
|
test:assertEquals(0, body1:getX(), 'check get x')
|
|
test:assertEquals(0, body1:getY(), 'check get y')
|
|
-- apply some force
|
|
local vel = body2:getAngularVelocity()
|
|
test:assertEquals(0, math.floor(vel), 'check velocity before')
|
|
body2:applyAngularImpulse(10)
|
|
vel = body2:getAngularVelocity()
|
|
test:assertEquals(54, math.floor(vel*10), 'check velocity after 1')
|
|
local ang = body2:getAngle()
|
|
test:assertEquals(149, math.floor(ang*1000), 'check initial angle')
|
|
body2:applyForce(2, 3)
|
|
world:update(2)
|
|
vel = body2:getAngularVelocity()
|
|
ang = body2:getAngle()
|
|
test:assertEquals(-84, math.floor(ang*1000), 'check angle after')
|
|
test:assertEquals(124, math.floor(vel*100), 'check velocity after 2')
|
|
body2:applyLinearImpulse(-4, -59)
|
|
world:update(1)
|
|
ang = body2:getAngle()
|
|
vel = body2:getAngularVelocity()
|
|
test:assertEquals(-1572, math.floor(ang*1000), 'check angle after 2')
|
|
test:assertEquals(9, math.floor(vel*100000000), 'check velocity after 3')
|
|
body2:applyTorque(4)
|
|
world:update(2)
|
|
ang = body2:getAngle()
|
|
vel = body2:getAngularVelocity()
|
|
test:assertEquals(-912, math.floor(ang*1000), 'check angle after 3')
|
|
test:assertEquals(321, math.floor(vel*1000), 'check velocity after 4')
|
|
test:assertEquals(false, body1:isDestroyed(), 'check not destroyed')
|
|
body1:destroy()
|
|
test:assertEquals(true, body1:isDestroyed(), 'check destroyed')
|
|
end
|
|
|
|
|
|
-- Contact (love.physics.World:getContacts)
|
|
love.test.physics.Contact = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 0, 0, 'dynamic')
|
|
local body2 = love.physics.newBody(world, 10, 10, 'dynamic')
|
|
local rectangle1 = love.physics.newRectangleShape(body1, 0, 0, 10, 10)
|
|
local rectangle2 = love.physics.newRectangleShape(body2, 0, 0, 10, 10)
|
|
rectangle1:setUserData('rec1')
|
|
rectangle2:setUserData('rec2')
|
|
local collided = false
|
|
local pass = 1
|
|
world:setCallbacks(
|
|
function(shape_a, shape_b, contact)
|
|
collided = true
|
|
test:assertObject(contact)
|
|
local indexA, indexB = contact:getChildren()
|
|
test:assertEquals(1, indexA, 'check child indice a')
|
|
test:assertEquals(1, indexB, 'check child indice b')
|
|
local shapeA, shapeB = contact:getShapes()
|
|
test:assertEquals(shape_a:getUserData(), shapeA:getUserData(), 'check shape a matches')
|
|
test:assertEquals(shape_b:getUserData(), shapeB:getUserData(), 'check shape b matches')
|
|
local nx, ny = contact:getNormal()
|
|
test:assertEquals(1, nx, 'check normal x')
|
|
test:assertEquals(0, ny, 'check normal y')
|
|
local px1, py1, px2, py2 = contact:getPositions()
|
|
test:assertEquals(5, math.floor(px1), 'check collide x 1')
|
|
test:assertEquals(5, math.floor(py1), 'check collide y 1')
|
|
test:assertEquals(5, math.floor(px2), 'check collide x 2')
|
|
test:assertEquals(5, math.floor(py2), 'check collide y 2')
|
|
test:assertEquals(true, contact:isTouching(), 'check touching')
|
|
test:assertEquals(pass == 1, contact:isEnabled(), 'check enabled for pass ' .. tostring(pass))
|
|
test:assertEquals(2, math.floor(contact:getFriction()*10), 'check def friction')
|
|
contact:setFriction(0.1)
|
|
test:assertEquals(1, math.floor(contact:getFriction()*10), 'check set friction')
|
|
contact:resetFriction()
|
|
test:assertEquals(2, math.floor(contact:getFriction()*10), 'check reset friction')
|
|
test:assertEquals(0, contact:getRestitution(), 'check def restitution')
|
|
contact:setRestitution(1)
|
|
test:assertEquals(1, contact:getRestitution(), 'check set restitution')
|
|
contact:resetRestitution()
|
|
test:assertEquals(0, contact:getRestitution(), 'check reset restitution')
|
|
pass = pass + 1
|
|
end, function() end, function(shape_a, shape_b, contact)
|
|
if pass > 2 then
|
|
contact:setEnabled(false)
|
|
end
|
|
end, function() end
|
|
)
|
|
world:update(1)
|
|
test:assertEquals(true, collided, 'check bodies collided')
|
|
-- update again for enabled check
|
|
world:update(1)
|
|
test:assertEquals(2, pass, 'check ran twice')
|
|
end
|
|
|
|
|
|
-- Joint (love.physics.newDistanceJoint)
|
|
love.test.physics.Joint = function(test)
|
|
-- make joint
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'dynamic')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'dynamic')
|
|
local joint = love.physics.newDistanceJoint(body1, body2, 10, 10, 20, 20, true)
|
|
test:assertObject(joint)
|
|
-- check props
|
|
test:assertEquals('distance', joint:getType(), 'check joint type')
|
|
test:assertEquals(false, joint:isDestroyed(), 'check not destroyed')
|
|
test:assertEquals(0, joint:getReactionForce(1), 'check reaction force')
|
|
test:assertEquals(0, joint:getReactionTorque(1), 'check reaction torque')
|
|
local b1, b2 = joint:getBodies()
|
|
test:assertEquals(body1:getX(), b1:getX(), 'check body 1')
|
|
test:assertEquals(body2:getX(), b2:getX(), 'check body 2')
|
|
local x1, y1, x2, y2 = joint:getAnchors()
|
|
test:assertEquals(10, math.floor(x1), 'check anchor x1')
|
|
test:assertEquals(10, math.floor(y1), 'check anchor y1')
|
|
test:assertEquals(20, math.floor(x2), 'check anchor x2')
|
|
test:assertEquals(20, math.floor(y2), 'check anchor y2')
|
|
test:assertEquals(true, joint:getCollideConnected(), 'check not colliding')
|
|
-- test userdata
|
|
test:assertEquals(nil, joint:getUserData(), 'check no data by def')
|
|
joint:setUserData('hello')
|
|
test:assertEquals('hello', joint:getUserData(), 'check set userdata')
|
|
-- destroy
|
|
joint:destroy()
|
|
test:assertEquals(true, joint:isDestroyed(), 'check destroyed')
|
|
end
|
|
|
|
|
|
--love.test.physics.Test1 = function(test)
|
|
-- local world = love.physics.newWorld(0, 0, false)
|
|
-- local body1 = love.physics.newBody(world, 0, 0, 'dynamic')
|
|
-- local shape1 = love.physics.newRectangleShape(body1, 5, 5, 10, 10)
|
|
-- local tlx, tly, brx, bry = shape1:getBoundingBox(1)
|
|
-- print('position:', tlx, tly, brx, bry) -- (-0.3, -0.3, 10.3, 10.3)
|
|
-- test:assertEquals(true, shape1:testPoint(5, 5), 'check point 1') -- returns false
|
|
--end
|
|
|
|
|
|
-- Shape (love.physics.newCircleShape)
|
|
-- @NOTE in 12.0 fixtures have been merged into shapes
|
|
love.test.physics.Shape = function(test)
|
|
-- create shape
|
|
local world = love.physics.newWorld(0, 0, false)
|
|
local body1 = love.physics.newBody(world, 0, 0, 'dynamic')
|
|
local shape1 = love.physics.newRectangleShape(body1, 5, 5, 10, 10)
|
|
test:assertObject(shape1)
|
|
-- check base properties
|
|
test:assertEquals(1, shape1:getChildCount(), 'check child count')
|
|
test:assertEquals(0, math.floor(shape1:getRadius()), 'check radius')
|
|
test:assertEquals('polygon', shape1:getType(), 'check rectangle type')
|
|
test:assertEquals(0, shape1:getBody():getX(), 'check body link')
|
|
test:assertEquals(1, shape1:getCategory(), 'check def category')
|
|
shape1:setCategory(3, 5, 6)
|
|
local categories = {shape1:getCategory()}
|
|
test:assertEquals(14, categories[1] + categories[2] + categories[3], 'check set category')
|
|
test:assertEquals(false, shape1:isSensor(), 'check sensor def')
|
|
shape1:setSensor(true)
|
|
test:assertEquals(true, shape1:isSensor(), 'check set sensor')
|
|
shape1:setSensor(false)
|
|
test:assertEquals(false, shape1:isDestroyed(), 'check not destroyed')
|
|
test:assertEquals(nil, shape1:getUserData(), 'check no user data')
|
|
shape1:setUserData({ test = 14 })
|
|
test:assertEquals(14, shape1:getUserData().test, 'check user data set')
|
|
-- check bounding box
|
|
-- polygons have an additional skin radius to help with collisions
|
|
-- so this wont be 0, 0, 10, 10 as you'd think but has an additional 0.3 padding
|
|
local topLeftX, topLeftY, bottomRightX, bottomRightY = shape1:computeAABB(0, 0, 0, 1)
|
|
local tlx, tly, brx, bry = shape1:getBoundingBox(1)
|
|
test:assertEquals(topLeftX, tlx, 'check bbox methods match tlx')
|
|
test:assertEquals(topLeftY, tly, 'check bbox methods match tly')
|
|
test:assertEquals(bottomRightX, brx, 'check bbox methods match brx')
|
|
test:assertEquals(bottomRightY, bry, 'check bbox methods match bry')
|
|
test:assertEquals(topLeftX, topLeftY, 'check bbox tl 1')
|
|
test:assertEquals(-3, math.floor(topLeftY*10), 'check bbox tl 2')
|
|
test:assertEquals(bottomRightX, bottomRightY, 'check bbox br 1')
|
|
test:assertEquals(10, math.floor(bottomRightX), 'check bbox br 2')
|
|
-- check physics props
|
|
test:assertEquals(1, shape1:getDensity(), 'check def density')
|
|
shape1:setDensity(5)
|
|
test:assertEquals(5, shape1:getDensity(), 'check set density')
|
|
local x, y, mass, inertia = shape1:getMassData()
|
|
test:assertEquals(5, math.floor(x), 'check shape mass pos x')
|
|
test:assertEquals(5, math.floor(y), 'check shape mass pos y')
|
|
test:assertEquals(5, math.floor(mass*10), 'check mass at 1 density')
|
|
test:assertEquals(0, math.floor(inertia*10), 'check intertia at 1 density')
|
|
x, y, mass, inertia = shape1:computeMass(1000)
|
|
test:assertEquals(111, math.floor(mass), 'check mass at 1000 density')
|
|
test:assertEquals(7407, math.floor(inertia), 'check intertia at 1000 density')
|
|
test:assertEquals(2, math.floor(shape1:getFriction()*10), 'check def friction')
|
|
shape1:setFriction(1)
|
|
test:assertEquals(1, shape1:getFriction(), 'check set friction')
|
|
test:assertEquals(0, shape1:getRestitution(), 'check def restitution')
|
|
shape1:setRestitution(0.5)
|
|
test:assertEquals(5, math.floor(shape1:getRestitution()*10), 'check set restitution')
|
|
-- check points
|
|
local shape2 = love.physics.newRectangleShape(body1, 5, 5, 10, 10)
|
|
tlx, tly, brx, bry = shape2:getBoundingBox(1)
|
|
test:assertEquals(true, shape2:testPoint(5, 5), 'check point 5,5')
|
|
test:assertEquals(true, shape2:testPoint(15, 15, 10, 10, 0), 'check point 15,15 after translate 10,10')
|
|
test:assertEquals(true, shape2:testPoint(15, 15, 10, 10, 90), 'check point 15,15 after translate 10,10,90')
|
|
test:assertEquals(false, shape2:testPoint(5, 5, 10, 10, 90), 'check point 5,5 after translate 10,10,90')
|
|
test:assertEquals(false, shape2:testPoint(15, 15), 'check point 15,15')
|
|
local xn, yn, fraction = shape2:rayCast(-20, -20, 20, 20, 100, 0, 0, 0, 1)
|
|
test:assertNotEquals(nil, xn, 'check ray 1 x')
|
|
test:assertNotEquals(nil, xn, 'check ray 1 y')
|
|
xn, yn, fraction = shape2:rayCast(10, 10, -150, -150, 100, 0, 0, 0, 1)
|
|
test:assertEquals(nil, xn, 'check ray 2 x')
|
|
test:assertEquals(nil, xn, 'check ray 2 y')
|
|
-- check filtering
|
|
test:assertEquals(nil, shape2:getMask(), 'check no mask')
|
|
shape2:setMask(1, 2, 3)
|
|
test:assertEquals(3, #{shape2:getMask()}, 'check set mask')
|
|
test:assertEquals(0, shape2:getGroupIndex(), 'check no index')
|
|
shape2:setGroupIndex(-1)
|
|
test:assertEquals(-1, shape2:getGroupIndex(), 'check set index')
|
|
local cat, mask, group = shape2:getFilterData()
|
|
test:assertEquals(1, cat, 'check filter cat')
|
|
test:assertEquals(65528, mask, 'check filter mask')
|
|
test:assertEquals(-1, group, 'check filter group')
|
|
-- run some collision checks using filters
|
|
shape1:destroy()
|
|
test:assertEquals(true, shape1:isDestroyed(), 'check destroyed')
|
|
shape2:destroy()
|
|
local body2 = love.physics.newBody(world, 5, 5, 'dynamic')
|
|
local shape3 = love.physics.newRectangleShape(body1, 0, 0, 10, 10)
|
|
local shape4 = love.physics.newRectangleShape(body2, 0, 0, 10, 10)
|
|
local collisions = 0
|
|
world:setCallbacks(
|
|
function() collisions = collisions + 1 end,
|
|
function() end,
|
|
function() end,
|
|
function() end
|
|
)
|
|
-- same group will always collide if the group is positive or never collide if it's negative
|
|
shape3:setGroupIndex(1)
|
|
shape4:setGroupIndex(1)
|
|
world:update(1)
|
|
test:assertEquals(1, collisions, 'check positive group collide')
|
|
shape3:setGroupIndex(-1)
|
|
shape4:setGroupIndex(-1)
|
|
body2:setPosition(20, 20); world:update(1); body2:setPosition(0, 0); world:update(1)
|
|
test:assertEquals(1, collisions, 'check negative group collide')
|
|
-- mask sets which categories this fixture should NOT collide with.
|
|
shape3:setGroupIndex(0)
|
|
shape4:setGroupIndex(0)
|
|
shape3:setCategory(2)
|
|
shape4:setMask(3)
|
|
body2:setPosition(20, 20); world:update(1); body2:setPosition(0, 0); world:update(1)
|
|
test:assertEquals(2, collisions, 'check mask collide')
|
|
shape3:setCategory(2)
|
|
shape4:setMask(2, 4, 6)
|
|
body2:setPosition(20, 20); world:update(1); body2:setPosition(0, 0); world:update(1)
|
|
test:assertEquals(2, collisions, 'check mask not collide')
|
|
end
|
|
|
|
|
|
-- World (love.physics.newWorld)
|
|
love.test.physics.World = function(test)
|
|
-- create new world
|
|
local world = love.physics.newWorld(0, 0, false)
|
|
local body1 = love.physics.newBody(world, 0, 0, 'dynamic')
|
|
local rectangle1 = love.physics.newRectangleShape(body1, 0, 0, 10, 10)
|
|
test:assertObject(world)
|
|
-- check defaults
|
|
test:assertEquals(1, #world:getBodies(), 'check 1 body')
|
|
test:assertEquals(0, world:getBodies()[1]:getX(), 'check body prop x')
|
|
test:assertEquals(0, world:getBodies()[1]:getY(), 'check body prop y')
|
|
world:translateOrigin(-10, -10)
|
|
test:assertEquals(10, math.floor(world:getBodies()[1]:getX()), 'check body prop change x')
|
|
test:assertEquals(10, math.floor(world:getBodies()[1]:getY()), 'check body prop change y')
|
|
test:assertEquals(1, world:getBodyCount(), 'check 1 body count')
|
|
test:assertEquals(false, world:isDestroyed(), 'check not destroyed')
|
|
test:assertEquals(false, world:isLocked(), 'check not updating')
|
|
test:assertEquals(0, #world:getJoints(), 'check no joints')
|
|
test:assertEquals(0, world:getJointCount(), 'check no joints count')
|
|
test:assertEquals(0, world:getGravity(), 'check def gravity')
|
|
test:assertEquals(0, #world:getContacts(), 'check no contacts')
|
|
test:assertEquals(0, world:getContactCount(), 'check no contact count')
|
|
test:assertEquals(false, world:isSleepingAllowed(), 'check no sleep (till brooklyn)')
|
|
world:setSleepingAllowed(true)
|
|
test:assertEquals(true, world:isSleepingAllowed(), 'check can sleep')
|
|
-- check callbacks are called
|
|
local beginContact, endContact, preSolve, postSolve = world:getCallbacks()
|
|
test:assertEquals(nil, beginContact, 'check no begin contact callback')
|
|
test:assertEquals(nil, endContact, 'check no end contact callback')
|
|
test:assertEquals(nil, preSolve, 'check no pre solve callback')
|
|
test:assertEquals(nil, postSolve, 'check no post solve callback')
|
|
local beginContactCheck = false
|
|
local endContactCheck = false
|
|
local preSolveCheck = false
|
|
local postSolveCheck = false
|
|
local collisions = 0
|
|
world:setCallbacks(
|
|
function() beginContactCheck = true; collisions = collisions + 1 end,
|
|
function() endContactCheck = true end,
|
|
function() preSolveCheck = true end,
|
|
function() postSolveCheck = true end
|
|
)
|
|
local body2 = love.physics.newBody(world, 10, 10, 'dynamic')
|
|
local rectangle2 = love.physics.newRectangleShape(body2, 0, 0, 10, 10)
|
|
test:assertEquals(false, beginContactCheck, 'check world didnt update after adding body')
|
|
world:update(1)
|
|
test:assertEquals(true, beginContactCheck, 'check contact start')
|
|
test:assertEquals(true, preSolveCheck, 'check pre solve')
|
|
test:assertEquals(true, postSolveCheck, 'check post solve')
|
|
body2:setPosition(100, 100)
|
|
world:update(1)
|
|
test:assertEquals(true, endContactCheck, 'check contact end')
|
|
-- check point checking
|
|
local shapes = 0
|
|
world:queryShapesInArea(0, 0, 10, 10, function(x)
|
|
shapes = shapes + 1
|
|
end)
|
|
test:assertEquals(1, shapes, 'check shapes in area')
|
|
world:rayCast(0, 0, 200, 200, function(x)
|
|
shapes = shapes + 1
|
|
return 1
|
|
end)
|
|
test:assertEquals(3, shapes, 'check shapes in raycast')
|
|
-- change collision logic
|
|
test:assertEquals(nil, world:getContactFilter(), 'check def filter')
|
|
world:update(1)
|
|
world:setContactFilter(function(s1, s2)
|
|
return false -- nothing collides
|
|
end)
|
|
body2:setPosition(10, 10)
|
|
world:update(1)
|
|
test:assertEquals(1, collisions, 'check collision logic change')
|
|
-- final bits
|
|
world:setGravity(1, 1)
|
|
test:assertEquals(1, world:getGravity(), 'check grav change')
|
|
world:destroy()
|
|
test:assertEquals(true, world:isDestroyed(), 'check world destroyed')
|
|
end
|
|
|
|
|
|
--------------------------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
------------------------------------METHODS-------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
|
|
|
|
-- love.physics.getDistance
|
|
love.test.physics.getDistance = function(test)
|
|
-- setup two fixtues to check
|
|
local world = love.physics.newWorld(0, 0, false)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
local shape1 = love.physics.newEdgeShape(body, 0, 0, 5, 5)
|
|
local shape2 = love.physics.newEdgeShape(body, 10, 10, 15, 15)
|
|
-- check distance between them
|
|
test:assertEquals(647106, math.floor(love.physics.getDistance(shape1, shape2)*100000), 'check distance matches')
|
|
end
|
|
|
|
|
|
-- love.physics.getMeter
|
|
love.test.physics.getMeter = function(test)
|
|
-- check value set is returned
|
|
love.physics.setMeter(30)
|
|
test:assertEquals(30, love.physics.getMeter(), 'check meter matches')
|
|
end
|
|
|
|
|
|
-- love.physics.newBody
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newBody = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
test:assertObject(body)
|
|
end
|
|
|
|
|
|
-- love.physics.newChainShape
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newChainShape = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
test:assertObject(love.physics.newChainShape(body, true, 0, 0, 1, 0, 1, 1, 0, 1))
|
|
end
|
|
|
|
|
|
-- love.physics.newCircleShape
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newCircleShape = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
test:assertObject(love.physics.newCircleShape(body, 10))
|
|
end
|
|
|
|
|
|
-- love.physics.newDistanceJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newDistanceJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newDistanceJoint(body1, body2, 10, 10, 20, 20, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newEdgeShape
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newEdgeShape = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
local obj = love.physics.newEdgeShape(body, 0, 0, 10, 10)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newFrictionJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newFrictionJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newFrictionJoint(body1, body2, 15, 15, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newGearJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newGearJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'dynamic')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'dynamic')
|
|
local body3 = love.physics.newBody(world, 30, 30, 'dynamic')
|
|
local body4 = love.physics.newBody(world, 40, 40, 'dynamic')
|
|
local joint1 = love.physics.newPrismaticJoint(body1, body2, 10, 10, 20, 20, true)
|
|
local joint2 = love.physics.newPrismaticJoint(body3, body4, 30, 30, 40, 40, true)
|
|
local obj = love.physics.newGearJoint(joint1, joint2, 1, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newMotorJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newMotorJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newMotorJoint(body1, body2, 1)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newMouseJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newMouseJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
local obj = love.physics.newMouseJoint(body, 10, 10)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newPolygonShape
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newPolygonShape = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
local obj = love.physics.newPolygonShape(body, {0, 0, 2, 3, 2, 1, 3, 1, 5, 1})
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newPrismaticJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newPrismaticJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newPrismaticJoint(body1, body2, 10, 10, 20, 20, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newPulleyJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newPulleyJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newPulleyJoint(body1, body2, 10, 10, 20, 20, 15, 15, 25, 25, 1, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newRectangleShape
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newRectangleShape = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body = love.physics.newBody(world, 10, 10, 'static')
|
|
local shape1 = love.physics.newRectangleShape(body, 10, 20)
|
|
local shape2 = love.physics.newRectangleShape(body, 10, 10, 40, 30, 10)
|
|
test:assertObject(shape1)
|
|
test:assertObject(shape2)
|
|
end
|
|
|
|
|
|
-- love.physics.newRevoluteJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newRevoluteJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newRevoluteJoint(body1, body2, 10, 10, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newRopeJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newRopeJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newRopeJoint(body1, body2, 10, 10, 20, 20, 50, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newWeldJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newWeldJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newWeldJoint(body1, body2, 10, 10, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newWheelJoint
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newWheelJoint = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
local body1 = love.physics.newBody(world, 10, 10, 'static')
|
|
local body2 = love.physics.newBody(world, 20, 20, 'static')
|
|
local obj = love.physics.newWheelJoint(body1, body2, 10, 10, 5, 5, true)
|
|
test:assertObject(obj)
|
|
end
|
|
|
|
|
|
-- love.physics.newWorld
|
|
-- @NOTE this is just basic nil checking, objs have their own test method
|
|
love.test.physics.newWorld = function(test)
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
test:assertObject(world)
|
|
end
|
|
|
|
|
|
-- love.physics.setMeter
|
|
love.test.physics.setMeter = function(test)
|
|
-- set initial meter
|
|
local world = love.physics.newWorld(1, 1, true)
|
|
love.physics.setMeter(30)
|
|
local body = love.physics.newBody(world, 300, 300, "dynamic")
|
|
-- check changing meter changes pos value relatively
|
|
love.physics.setMeter(10)
|
|
local x, y = body:getPosition()
|
|
test:assertEquals(100, x, 'check pos x')
|
|
test:assertEquals(100, y, 'check pos y')
|
|
end
|