mirror of
https://github.com/codeninjasllc/codecombat.git
synced 2024-12-12 00:31:21 -05:00
197 lines
7.2 KiB
CoffeeScript
197 lines
7.2 KiB
CoffeeScript
Vector = require './vector'
|
|
LineSegment = require './line_segment'
|
|
|
|
class Rectangle
|
|
@className: 'Rectangle'
|
|
# Class methods for nondestructively operating - TODO: add rotate
|
|
for name in ['add', 'subtract', 'multiply', 'divide']
|
|
do (name) ->
|
|
Rectangle[name] = (a, b) ->
|
|
a.copy()[name](b)
|
|
|
|
isRectangle: true
|
|
apiProperties: ['x', 'y', 'width', 'height', 'rotation', 'getPos', 'vertices', 'touchesRect', 'touchesPoint', 'distanceToPoint', 'distanceSquaredToPoint', 'distanceToRectangle', 'distanceSquaredToRectangle', 'distanceToEllipse', 'distanceSquaredToEllipse', 'distanceToShape', 'distanceSquaredToShape', 'containsPoint', 'copy', 'intersectsLineSegment', 'intersectsEllipse', 'intersectsRectangle', 'intersectsShape']
|
|
|
|
constructor: (@x=0, @y=0, @width=0, @height=0, @rotation=0) ->
|
|
|
|
copy: ->
|
|
new Rectangle(@x, @y, @width, @height, @rotation)
|
|
|
|
getPos: ->
|
|
new Vector(@x, @y)
|
|
|
|
vertices: ->
|
|
# Counter-clockwise, starting from bottom left (when unrotated)
|
|
[w2, h2, cos, sin] = [@width / 2, @height / 2, Math.cos(@rotation), Math.sin(-@rotation)]
|
|
[
|
|
new Vector @x - (w2 * cos - h2 * sin), @y - (w2 * sin + h2 * cos)
|
|
new Vector @x - (w2 * cos + h2 * sin), @y - (w2 * sin - h2 * cos)
|
|
new Vector @x + (w2 * cos - h2 * sin), @y + (w2 * sin + h2 * cos)
|
|
new Vector @x + (w2 * cos + h2 * sin), @y + (w2 * sin - h2 * cos)
|
|
]
|
|
|
|
lineSegments: ->
|
|
vertices = @vertices()
|
|
lineSegment0 = new LineSegment vertices[0], vertices[1]
|
|
lineSegment1 = new LineSegment vertices[1], vertices[2]
|
|
lineSegment2 = new LineSegment vertices[2], vertices[3]
|
|
lineSegment3 = new LineSegment vertices[3], vertices[0]
|
|
[lineSegment0, lineSegment1, lineSegment2, lineSegment3]
|
|
|
|
touchesRect: (other) ->
|
|
# Whether this rect shares part of any edge with other rect, for non-rotated, non-overlapping rectangles.
|
|
# I think it says kitty-corner rects touch, but I don't think I want that.
|
|
# Float instability might get me, too.
|
|
[bl1, tl1, tr1, br1] = @vertices()
|
|
[bl2, tl2, tr2, br2] = other.vertices()
|
|
return false if tl1.x > tr2.x or tl2.x > tr1.x
|
|
return false if bl1.y > tl2.y or bl2.y > tl1.y
|
|
return true if tl1.x is tr2.x or tl2.x is tr1.x
|
|
return true if tl1.y is bl2.y or tl2.y is bl1.y
|
|
false
|
|
|
|
touchesPoint: (p) ->
|
|
# Whether this rect has point p exactly on one of its edges, assuming no rotation.
|
|
[bl, tl, tr, br] = @vertices()
|
|
return false unless p.y >= bl.y and p.y <= tl.y
|
|
return false unless p.x >= bl.x and p.x <= br.x
|
|
return true if p.x is bl.x or p.x is br.x
|
|
return true if p.y is bl.y or p.y is tl.y
|
|
false
|
|
|
|
axisAlignedBoundingBox: (rounded=true) ->
|
|
box = @copy()
|
|
return box unless @rotation
|
|
box.rotation = 0
|
|
[left, top] = [9001, 9001]
|
|
for vertex in @vertices()
|
|
[left, top] = [Math.min(left, vertex.x), Math.min(top, vertex.y)]
|
|
if rounded
|
|
[left, top] = [Math.round(left), Math.round(top)]
|
|
[box.width, box.height] = [2 * (@x - left), 2 * (@y - top)]
|
|
box
|
|
|
|
distanceToPoint: (p) ->
|
|
# Get p in rect's coordinate space, then operate in one quadrant.
|
|
p = Vector.subtract(p, @getPos()).rotate(-@rotation)
|
|
dx = Math.max(Math.abs(p.x) - @width / 2, 0)
|
|
dy = Math.max(Math.abs(p.y) - @height / 2, 0)
|
|
Math.sqrt dx * dx + dy * dy
|
|
|
|
distanceSquaredToPoint: (p) ->
|
|
# Doesn't handle rotation; just supposed to be faster than distanceToPoint.
|
|
p = Vector.subtract(p, @getPos())
|
|
dx = Math.max(Math.abs(p.x) - @width / 2, 0)
|
|
dy = Math.max(Math.abs(p.y) - @height / 2, 0)
|
|
dx * dx + dy * dy
|
|
|
|
distanceToRectangle: (other) ->
|
|
Math.sqrt @distanceSquaredToRectangle other
|
|
|
|
distanceSquaredToRectangle: (other) ->
|
|
return 0 if @intersectsRectangle other
|
|
[firstVertices, secondVertices] = [@vertices(), other.vertices()]
|
|
[firstEdges, secondEdges] = [@lineSegments(), other.lineSegments()]
|
|
ans = Infinity
|
|
for i in [0 ... 4]
|
|
for j in [0 ... firstEdges.length]
|
|
ans = Math.min ans, firstEdges[j].distanceSquaredToPoint(secondVertices[i])
|
|
for j in [0 ... secondEdges.length]
|
|
ans = Math.min ans, secondEdges[j].distanceSquaredToPoint(firstVertices[i])
|
|
ans
|
|
|
|
distanceToEllipse: (ellipse) ->
|
|
Math.sqrt @distanceSquaredToEllipse ellipse
|
|
|
|
distanceSquaredToEllipse: (ellipse) ->
|
|
@distanceSquaredToRectangle ellipse.rectangle() # TODO: actually implement rectangle-ellipse distance
|
|
|
|
distanceToShape: (shape) ->
|
|
Math.sqrt @distanceSquaredToShape shape
|
|
|
|
distanceSquaredToShape: (shape) ->
|
|
if shape.isEllipse then @distanceSquaredToEllipse shape else @distanceSquaredToRectangle shape
|
|
|
|
containsPoint: (p, withRotation=true) ->
|
|
if withRotation and @rotation
|
|
not @distanceToPoint(p)
|
|
else
|
|
@x - @width / 2 < p.x < @x + @width / 2 and @y - @height / 2 < p.y < @y + @height / 2
|
|
|
|
intersectsLineSegment: (p1, p2) ->
|
|
[px1, py1, px2, py2] = [p1.x, p1.y, p2.x, p2.y]
|
|
m1 = (py1 - py2) / (px1 - px2)
|
|
b1 = py1 - (m1 * px1)
|
|
vertices = @vertices()
|
|
lineSegments = [[vertices[0], vertices[1]], [vertices[1], vertices[2]], [vertices[2], vertices[3]], [vertices[3], vertices[0]]]
|
|
for lineSegment in lineSegments
|
|
[px1, py1, px2, py2] = [p1.x, p1.y, p2.x, p2.y]
|
|
m2 = (py1 - py2) / (px1 - px2)
|
|
b2 = py1 - (m * px1)
|
|
if m1 isnt m2
|
|
m = m1 - m2
|
|
b = b2 - b1
|
|
x = b / m
|
|
[littleX, bigX] = if px1 < px2 then [px1, px2] else [px2, px1]
|
|
if x >= littleX and x <= bigX
|
|
y = (m1 * x) + b1
|
|
[littleY, bigY] = if py1 < py2 then [py1, py2] else [py2, py1]
|
|
if littleY <= solution and bigY >= solution
|
|
return true
|
|
false
|
|
|
|
intersectsRectangle: (rectangle) ->
|
|
return true if @containsPoint rectangle.getPos()
|
|
for thisLineSegment in @lineSegments()
|
|
for thatLineSegment in rectangle.lineSegments()
|
|
if thisLineSegment.intersectsLineSegment(thatLineSegment)
|
|
return true
|
|
false
|
|
|
|
intersectsEllipse: (ellipse) ->
|
|
return true if @containsPoint ellipse.getPos()
|
|
return true for lineSegment in @lineSegments() when ellipse.intersectsLineSegment lineSegment.a, lineSegment.b
|
|
false
|
|
|
|
intersectsShape: (shape) ->
|
|
if shape.isEllipse then @intersectsEllipse shape else @intersectsRectangle shape
|
|
|
|
subtract: (point) ->
|
|
@x -= point.x
|
|
@y -= point.y
|
|
@pos.subtract point
|
|
@
|
|
|
|
add: (point) ->
|
|
@x += point.x
|
|
@y += point.y
|
|
@pos.add point
|
|
@
|
|
|
|
divide: (n) ->
|
|
[@width, @height] = [@width / n, @height / n]
|
|
@
|
|
|
|
multiply: (n) ->
|
|
[@width, @height] = [@width * n, @height * n]
|
|
@
|
|
|
|
isEmpty: () ->
|
|
@width is 0 and @height is 0
|
|
|
|
invalid: () ->
|
|
return (@x is Infinity) || isNaN(@x) || @y is Infinity || isNaN(@y) || @width is Infinity || isNaN(@width) || @height is Infinity || isNaN(@height) || @rotation is Infinity || isNaN(@rotation)
|
|
|
|
toString: ->
|
|
return "{x: #{@x.toFixed(0)}, y: #{@y.toFixed(0)}, w: #{@width.toFixed(0)}, h: #{@height.toFixed(0)}, rot: #{@rotation.toFixed(3)}}"
|
|
|
|
serialize: ->
|
|
{CN: @constructor.className, x: @x, y: @y, w: @width, h: @height, r: @rotation}
|
|
|
|
@deserialize: (o, world, classMap) ->
|
|
new Rectangle o.x, o.y, o.w, o.h, o.r
|
|
|
|
serializeForAether: -> @serialize()
|
|
@deserializeFromAether: (o) -> @deserialize o
|
|
|
|
module.exports = Rectangle
|