mirror of
https://github.com/codeninjasllc/codecombat.git
synced 2024-12-25 23:12:29 -05:00
190 lines
7.4 KiB
CoffeeScript
190 lines
7.4 KiB
CoffeeScript
describe 'Camera (Surface point of view)', ->
|
|
Camera = require 'lib/surface/Camera'
|
|
|
|
expectPositionsEqual = (p1, p2) ->
|
|
expect(p1.x).toBeCloseTo p2.x
|
|
expect(p1.y).toBeCloseTo p2.y
|
|
expect(p1.z).toBeCloseTo p2.z if p2.z?
|
|
|
|
checkConversionsFromWorldPos = (wop, cam) ->
|
|
# wop = world pos
|
|
# sup = surface pos
|
|
# cap = canvas pos
|
|
# scp = screen pos
|
|
|
|
sup = cam.worldToSurface wop
|
|
expect(sup.x).toBeCloseTo wop.x * Camera.PPM
|
|
expect(sup.y).toBeCloseTo -(wop.y + wop.z * cam.z2y) * cam.y2x * Camera.PPM
|
|
|
|
cap = cam.worldToCanvas wop
|
|
expect(cap.x).toBeCloseTo (sup.x - cam.surfaceViewport.x) * cam.zoom
|
|
expect(cap.y).toBeCloseTo (sup.y - cam.surfaceViewport.y) * cam.zoom
|
|
|
|
scp = cam.worldToScreen wop
|
|
# If we ever want to use screen conversion, then make it and add this test
|
|
#expect(scp.x).toBeCloseTo cap.x * @someCanvasToScreenXScaleFactor
|
|
#expect(scp.y).toBeCloseTo cap.y * @someCanvasToScreenYScaleFactor
|
|
|
|
wop2 = cam.surfaceToWorld sup
|
|
expect(wop2.x).toBeCloseTo wop.x
|
|
expect(wop2.y).toBeCloseTo wop.y + wop.z * cam.z2y
|
|
|
|
# Make sure to call all twelve conversions in here. Can be redundant.
|
|
expectPositionsEqual sup, cam.worldToSurface wop2 # 0
|
|
expectPositionsEqual cap, cam.surfaceToCanvas sup # 1
|
|
expectPositionsEqual scp, cam.canvasToScreen cap # 2
|
|
expectPositionsEqual cap, cam.screenToCanvas scp # 3
|
|
expectPositionsEqual sup, cam.canvasToSurface cap # 4
|
|
expectPositionsEqual wop2, cam.surfaceToWorld sup # 5
|
|
expectPositionsEqual wop2, cam.canvasToWorld cap # 6
|
|
expectPositionsEqual cap, cam.worldToCanvas wop # 7
|
|
expectPositionsEqual scp, cam.worldToScreen wop # 8
|
|
expectPositionsEqual scp, cam.surfaceToScreen sup # 9
|
|
expectPositionsEqual sup, cam.screenToSurface scp # 10
|
|
expectPositionsEqual wop2, cam.screenToWorld scp # 11
|
|
|
|
checkCameraPos = (cam, wop) ->
|
|
botFOV = cam.x2y * cam.vFOV / (cam.y2x + cam.x2y)
|
|
botDist = (cam.worldViewport.height) * Math.sin(cam.angle) / Math.sin(botFOV)
|
|
camDist = (cam.worldViewport.height / 2) * Math.sin(Math.PI - cam.angle - botFOV) / Math.sin(botFOV)
|
|
targetPos =
|
|
x: cam.worldViewport.cx
|
|
y: cam.worldViewport.cy - camDist * cam.y2x * cam.z2y
|
|
z: camDist * cam.z2x * cam.y2z
|
|
#console.log 'botFOV', botFOV * 180 / Math.PI, 'botDist', botDist, 'camDist', camDist, 'target pos', targetPos, 'actual pos', cam.cameraWorldPos()
|
|
expectPositionsEqual cam.cameraWorldPos(), targetPos
|
|
|
|
if wop
|
|
dx = targetPos.x - wop.x
|
|
dy = targetPos.y - wop.y
|
|
dz = targetPos.z - wop.z
|
|
d = cam.distanceTo wop
|
|
expect(d).toBeCloseTo Math.sqrt(dx * dx + dy * dy + dz * dz)
|
|
# This is fairly vulnerable to numerical instability, so we limit the number of digits to consider.
|
|
decimalPlaces = 3 - Math.floor(Math.log(d / camDist) / Math.log(10))
|
|
expect(cam.distanceRatioTo wop).toBeCloseTo d / camDist, decimalPlaces
|
|
|
|
testWops = [
|
|
{x: 3, y: 4, z: 7}
|
|
{x: -4, y: 12, z: 2}
|
|
{x: 0, y: 0, z: 0}
|
|
]
|
|
testCanvasSizes = [
|
|
{width: 100, height: 100}
|
|
{width: 200, height: 50}
|
|
]
|
|
testLayer = {scaleX: 1, scaleY: 1, regX: 0, regY: 0}
|
|
testZooms = [0.5, 1, 2]
|
|
testZoomTargets = [
|
|
null,
|
|
{x: 50, y: 50}
|
|
{x: 0, y: 150}
|
|
]
|
|
testAngles = [0, Math.PI / 4, null, Math.PI / 2]
|
|
testFOVs = [Math.PI / 6, Math.PI / 3, Math.PI / 2, Math.PI]
|
|
|
|
it 'handles lots of different cases correctly', ->
|
|
for wop in testWops
|
|
for size in testCanvasSizes
|
|
for zoom in testZooms
|
|
for target in testZoomTargets
|
|
for angle in testAngles
|
|
for fov in testFOVs
|
|
cam = new Camera {attr: (attr) -> if 'attr' is 'width' then size.width else size.height}, angle, fov
|
|
checkCameraPos cam, wop
|
|
cam.zoomTo target, zoom, 0
|
|
checkConversionsFromWorldPos wop, cam
|
|
checkCameraPos cam, wop
|
|
|
|
it 'works at 90 degrees', ->
|
|
cam = new Camera {attr: (attr) -> 100}, Math.PI / 2
|
|
expect(cam.x2y).toBeCloseTo 1
|
|
expect(cam.x2z).toBeGreaterThan 9001
|
|
expect(cam.z2y).toBeCloseTo 0
|
|
|
|
it 'works at 0 degrees', ->
|
|
cam = new Camera {attr: (attr) -> 100}, 0
|
|
expect(cam.x2y).toBeGreaterThan 9001
|
|
expect(cam.x2z).toBeCloseTo 1
|
|
expect(cam.z2y).toBeGreaterThan 9001
|
|
|
|
it 'works at 45 degrees', ->
|
|
cam = new Camera {attr: (attr) -> 100}, Math.PI / 4
|
|
expect(cam.x2y).toBeCloseTo Math.sqrt(2)
|
|
expect(cam.x2z).toBeCloseTo Math.sqrt(2)
|
|
expect(cam.z2y).toBeCloseTo 1
|
|
|
|
it 'works at default angle of asin(0.75) ~= 48.9 degrees', ->
|
|
cam = new Camera {attr: (attr) -> 100}, null
|
|
angle = Math.asin(3 / 4)
|
|
expect(cam.angle).toBeCloseTo angle
|
|
expect(cam.x2y).toBeCloseTo 4 / 3
|
|
expect(cam.x2z).toBeCloseTo 1 / Math.cos angle
|
|
expect(cam.z2y).toBeCloseTo (4 / 3) * Math.cos angle
|
|
|
|
xit 'works at 2x zoom, 90 degrees', ->
|
|
cam = new Camera {attr: (attr) -> 100}, Math.PI / 2
|
|
cam.zoomTo null, 2, 0
|
|
checkCameraPos cam
|
|
wop = x: 5, y: 2.5, z: 7
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 50, y: 100}
|
|
cam.zoomTo {x: 50, y: 75}, 2, 0
|
|
checkCameraPos cam
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 50, y: 50}
|
|
cam.zoomTo {x: 50, y: 75}, 4, 0
|
|
checkCameraPos cam
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 50, y: 50}
|
|
# Now let's try zooming on the edge of the screen; we should be bounded to the surface viewport
|
|
cam.zoomTo {x: 100, y: 100}, 2, 0
|
|
checkCameraPos cam
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 0, y: 50}
|
|
|
|
xit 'works at 2x zoom, 30 degrees', ->
|
|
cam = new Camera {attr: (attr) -> 100}, Math.PI / 6
|
|
cam.zoomTo null, 2, 0
|
|
expect(cam.x2y).toBeCloseTo 1
|
|
expect(cam.x2z).toBeGreaterThan 9001
|
|
checkCameraPos cam
|
|
wop = x: 5, y: 4, z: 6 * cam.y2z # like x: 5, y: 10 out of world width: 10, height: 20
|
|
sup = cam.worldToSurface wop
|
|
expect(cam.surfaceToWorld(sup).y).toBeCloseTo 10
|
|
expectPositionsEqual sup, {x: 50, y: 50}
|
|
cap = cam.surfaceToCanvas sup
|
|
expectPositionsEqual cap, {x: 50, y: 50}
|
|
# Zoom to bottom edge of screen
|
|
cam.zoomTo {x: 50, y: 100}, 2, 0
|
|
checkCameraPos cam
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 50, y: 0}
|
|
cam.zoomTo {x: 50, y: 100}, 4, 0
|
|
checkCameraPos cam
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 50, y: -100}
|
|
|
|
it 'works at 2x zoom, 60 degree hFOV', ->
|
|
cam = new Camera {attr: (attr) -> 100}, null, Math.PI / 3
|
|
cam.zoomTo null, 2, 0
|
|
checkCameraPos cam
|
|
|
|
it 'works at 2x zoom, 60 degree hFOV, 40 degree vFOV', ->
|
|
cam = new Camera {attr: (attr) -> if attr is 'height' then 63.041494 else 100}, null, Math.PI / 3
|
|
cam.zoomTo null, 2, 0
|
|
checkCameraPos cam
|
|
|
|
xit 'works at 2x zoom on a surface wider than it is tall, 30 degrees, default viewing upper left corner', ->
|
|
cam = new Camera {attr: (attr) -> 100}, Math.PI / 6 # 200 * Camera.MPP, 2 * 50 * Camera.MPP
|
|
cam.zoomTo null, 2, 0
|
|
checkCameraPos cam
|
|
expect(cam.zoom).toBeCloseTo 2
|
|
wop = x: 5, y: 4, z: 6 * cam.y2z # like x: 5, y: 10 out of world width: 20, height: 10
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: 100, y: 0}
|
|
# Zoom to far right edge of screen and try to zoom out
|
|
cam.zoomTo {x: 9001, y: 25}, 0.1, 0
|
|
checkCameraPos cam
|
|
cap = cam.worldToCanvas wop
|
|
expectPositionsEqual cap, {x: -200, y: 0}
|