agt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7bcb67eb9415c02fa8086e62407819b7aface85f
+  data.tar.gz: f96ea9a25186d7ea3010a892816cce8758fb9661
+SHA512:
+  metadata.gz: 888e8ce59fda8602529542eb5d2cc57f3bd2d2509cc14176135de918c0d01178de50d0d384b6f77e2251d5d19e252616719f5fd1202bab897e6e0171bff4bfe8
+  data.tar.gz: 9e6cac65330d02b561882454a7cd4f48a6606d9d1b6e3194787e0c08c4b09b76b524389f05590bc1e8eda932416359fd34406ae4765909eee60ce82ed0eee55e

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2014 Cédric Néhémie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,5 @@
+## Game Tools
+
+[![Travis Status](https://travis-ci.org/abe33/agt.png)](https://travis-ci.org/abe33/agt)
+
+[![Browser Testing CI Status](https://ci.testling.com/abe33/agt.png)](https://ci.testling.com/abe33/agt)

data/app/assets/javascripts/agt/config.coffee

@@ -0,0 +1,9 @@
+
+agt.CAMEL_CASE = 'camel'
+agt.SNAKE_CASE = 'snake'
+agt.COLORS =
+  STROKE: '#ff0000'
+  FILL: 'rgba(255,0,0,0.5)'
+  VERTICES: '#0077ff'
+  VERTICES_CONNECTIONS: 'rgba(0,127,255,0.5)'
+  BOUNDING_BOX: '#69af23'

data/app/assets/javascripts/agt/dom.coffee

@@ -0,0 +1,12 @@
+agt.domEvent = (type, data={}, options={bubbles, cancelable}={}) ->
+  try
+    event = new Event type, {
+      bubbles: bubbles ? true
+      cancelable: cancelable ? true
+    }
+  catch e
+    event = document.createEvent 'Event'
+    event.initEvent type, bubbles ? true, cancelable ? true
+
+  event.data = data
+  event

data/app/assets/javascripts/agt/function.coffee

@@ -0,0 +1,317 @@
+### Public ###
+
+# Creates a new non-enumerable method on the current class prototype.
+#
+# ```coffeescript
+# class Dummy
+#   @def 'method', ->
+# ```
+#
+# name - The {String} for the method name.
+# block - The {Function} body.
+Function::def = (name, block) ->
+  Object.defineProperty @prototype, name, {
+    value: block
+    configurable: true
+    enumerable: false
+  }
+  this
+
+# Creates a virtual property on the current class's prototype.
+#
+# ```coffeescript
+# class Dummy
+#   @accessor 'foo', {
+#     get: -> @fooValue * 2
+#     set: (value) -> @fooValue = value / 2
+#   }
+#
+# dummy = new Dummy
+# dummy.foo = 10
+# dummy.fooValue # 5
+# dummy.foo      # 10
+# ```
+#
+# name - The {String} for the accessor name.
+# options - A descriptor {Object} for the accessor. It can contains
+#           the following properties:
+#           get - A {Function} to read the property's value.
+#           set - A {Function} to write the property's value.
+Function::accessor = (name, options) ->
+  oldDescriptor = Object.getPropertyDescriptor @prototype, name
+
+  options.get ||= oldDescriptor.get if oldDescriptor?
+  options.set ||= oldDescriptor.set if oldDescriptor?
+
+  Object.defineProperty @prototype, name, {
+    get: options.get
+    set: options.set
+    configurable: true
+    enumerable: true
+  }
+  this
+
+# Creates a getter on the given class prototype.
+#
+# ```coffeescript
+# class Dummy
+#   @getter 'foo', -> 'bar'
+# ```
+#
+# name - The {String} name of the property accessor to create.
+# block - The {Function} to read the property value.
+Function::getter = (name, block) -> @accessor name, get: block
+
+# Creates a setter on the given class prototype.
+#
+# ```coffeescript
+# class Dummy
+#   @setter 'foo', (value) -> @fooValue = value / 2
+# ```
+#
+# name - The {String} name of the property accessor to create.
+# block - The {Function} to write the property value.
+Function::setter = (name, block) -> @accessor name, set: block
+
+# Internal: Registers a method as the super method for another method
+# for the given class. The super methods are stored in a map structure
+# where the `__included__` array stores the keys and the `__super__`
+# array stores the values. A meaningful name is added to the function
+# to know its origin.
+#
+# key - The {String} name of the field that is being manipulated.
+# value - A {Function} that will be set as the new value of the field.
+# klass - The {Function} that is or has its prototype being manipulated.
+# sup - The {Function} that is actually stored in the manipulated field
+#       and that is going to become the super method of the passed-in `value`.
+# mixin - The {Function} mixin that is currently decorating the target class.
+registerSuper = (key, value, klass, sup, mixin) ->
+  return if value.__included__? and klass in value.__included__
+
+  value.__super__ ||= []
+  value.__super__.push sup
+
+  value.__included__ ||= []
+  value.__included__.push klass
+
+  value.__name__ = "#{mixin.name}::#{key}"
+
+# Injects the properties from the mixin in the `mixins` {Array}
+# into the target prototype.
+#
+#
+# ```coffeescript
+# class Mixin
+#   instanceMethod: -> 'in the instance'
+#
+# class Dummy
+#   @include Mixin
+#
+# dummy = new Dummy
+# dummy.instanceMethod() # 'in the instance'
+# ```
+#
+# ```coffeescript
+# class Dummy
+#   @include MixinA, MixinB, MixinC
+# ```
+#
+# mixins - A list of `Mixin` to include in the class.
+Function::include = (mixins...) ->
+
+  # The mixins prototype constructor and excluded properties
+  # are always excluded.
+  excluded = ['constructor', 'excluded', 'super']
+
+  # Internal: Stores the mixins included in the current class.
+  @__mixins__ ||= []
+
+  # Internal: Stores the parent class prototype when the `extend`
+  # keyword is used. It also stores mixins methods when the class doesn't
+  # extend another class.
+  @__super__ ||= {}
+
+  # We create a new `__super__` using the previous one as prototype.
+  # It allow to have mixins overrides some properties already defined
+  # by a parent prototype without actually modifying this prototype.
+  @__super__ = Object.create @__super__
+
+  # For each mixin passed to the `include` class method:
+  # We'll store the mixin in the `__mixins__` array to keep track of
+  # its inclusion.
+  for mixin in mixins
+    @__mixins__.push mixin
+
+    # A new Array is created to store the exclusion list of the current
+    # mixin. It is based on the default exclusion array.
+    excl = excluded.concat()
+    excl = excl.concat mixin::excluded if mixin::excluded?
+
+    # We loop through all the enumerable properties of the mixin's
+    # prototype that is not marked for exclusion.
+    keys = Object.keys mixin.prototype
+    for k in keys
+      if k not in excl
+
+        # We prefer working with property descriptors rather than with
+        # the plain values.
+        oldDescriptor = Object.getPropertyDescriptor @prototype, k
+        newDescriptor = Object.getPropertyDescriptor mixin.prototype, k
+
+        # If the two descriptors are available we'll have to go deeper.
+        if oldDescriptor? and newDescriptor?
+          oldHasAccessor = oldDescriptor.get? or oldDescriptor.set?
+          newHasAccessor = newDescriptor.get? or newDescriptor.set?
+          bothHaveGet = oldDescriptor.get? and newDescriptor.get?
+          bothHaveSet = oldDescriptor.set? and newDescriptor.set?
+          bothHaveValue = oldDescriptor.value? and newDescriptor.value?
+
+          # When both properties are accessors we'll be able to follow
+          # the super accross them.
+          #
+          # Super methods are registered if both are there for getters
+          # and setters.
+          if oldHasAccessor and newHasAccessor
+            registerSuper k, newDescriptor.get, @, oldDescriptor.get, mixin if bothHaveGet
+            registerSuper k, newDescriptor.set, @, oldDescriptor.set, mixin if bothHaveSet
+
+            # If there was a getter or a setter and the new accessor
+            # doesn't define one them, the previous value is used.
+            newDescriptor.get ||= oldDescriptor.get
+            newDescriptor.set ||= oldDescriptor.set
+
+          # When both have a value, the super is also available.
+          else if bothHaveValue
+            registerSuper k, newDescriptor.value, @, oldDescriptor.value, mixin
+
+          else
+            throw new Error "Can't mix accessors and plain values inheritance"
+
+          # We also have to create the property on the class `__super__`
+          # property. It'll allow the method defined on the class itself
+          # and overriding the property to have access to its super property
+          # through the `super` keyword or with `this.super` method.
+          Object.defineProperty @__super__, k, newDescriptor
+
+        # We only have a descriptor for the new property, the previous
+        # one is just added to the class `__super__` property.
+        else if newDescriptor?
+          @__super__[k] = mixin[k]
+
+        # We only have a descriptor for the previous property, we'll
+        # create it on the class `__super__` property.
+        else if oldDescriptor?
+          Object.defineProperty @__super__, k, newDescriptor
+
+        # No descriptors at all. The super property is attached directly
+        # to the value.
+        else if @::[k]?
+          registerSuper k, mixin[k], @, @::[k], mixin
+          @__super__[k] = mixin[k]
+
+        # With a descriptor the new property is created using
+        # `Object.defineProperty` or by affecting the value
+        # to the prototype.
+        if newDescriptor?
+          Object.defineProperty @prototype, k, newDescriptor
+        else
+          @::[k] = mixin::[k]
+
+    # The `included` hook is triggered on the mixin.
+    mixin.included? this
+
+  this
+
+# Extends the current class with the properties of the passed-in
+# `mixins`.
+#
+# ```coffeescript
+# class Mixin
+#   @classMethod: -> 'in the class'
+#
+# class Dummy
+#   @extend Mixin
+#
+# Dummy.classMethod() # 'in the class'
+# ```
+#
+# mixins - A list of `Mixin` to extend this class.
+Function::extend = (mixins...) ->
+  excluded = ['extended', 'excluded', 'included']
+
+  # The `__mixins__` class property will stores the mixins included
+  # in the current class.
+  @__mixins__ ||= []
+
+  for mixin in mixins
+    @__mixins__.push mixin
+
+    excl = excluded.concat()
+    excl = excl.concat mixin.excluded if mixin.excluded?
+
+    keys = Object.keys mixin
+    for k in keys
+      if k not in excl
+        oldDescriptor = Object.getPropertyDescriptor this, k
+        newDescriptor = Object.getPropertyDescriptor mixin, k
+
+        if oldDescriptor? and newDescriptor?
+          oldHasAccessor = oldDescriptor.get? or oldDescriptor.set?
+          newHasAccessor = newDescriptor.get? or newDescriptor.set?
+          bothHaveGet = oldDescriptor.get? and newDescriptor.get?
+          bothHaveSet = oldDescriptor.set? and newDescriptor.set?
+          bothHaveValue = oldDescriptor.value? and newDescriptor.value?
+
+          # When both properties are accessors we'll be able to follow
+          # the super accross them
+          #
+          # Super methods are registered if both are there for getters
+          # and setters.
+          if oldHasAccessor and newHasAccessor
+            registerSuper k, newDescriptor.get, @, oldDescriptor.get, mixin if bothHaveGet
+            registerSuper k, newDescriptor.set, @, oldDescriptor.set, mixin if bothHaveSet
+
+            # If there was a getter or a setter and the new accessor
+            # doesn't define one them, the previous value is used.
+            newDescriptor.get ||= oldDescriptor.get
+            newDescriptor.set ||= oldDescriptor.set
+
+          # When both have a value, the super is also available.
+          else if bothHaveValue
+            registerSuper k, newDescriptor.value, @, oldDescriptor.value, mixin
+
+          else
+            throw new Error "Can't mix accessors and plain values inheritance"
+
+        # With a descriptor the new property is created using
+        # `Object.defineProperty` or by affecting the value
+        # to the prototype.
+        if newDescriptor?
+          Object.defineProperty this, k, newDescriptor
+        else
+          @[k] = mixin[k]
+
+    mixin.extended? this
+
+  this
+
+# Combinates `Function::include` and `Function::extend` into
+# one function.
+#
+# ```coffeescript
+# class Mixin
+#   @classMethod: -> 'in class method'
+#   instanceMethod: -> 'in instance method'
+#
+# class Dummy
+#   @concern Mixin
+#
+# Dummy.classMethod() # 'in class method'
+# dummy = new Dummy
+# dummy.instanceMethod() # 'in instance method'
+# ```
+#
+# mixins - A list of `Mixin` that concern the class.
+Function::concern = (mixins...) ->
+  @include.apply(this, mixins)
+  @extend.apply(this, mixins)

data/app/assets/javascripts/agt/geom/circle.coffee

@@ -0,0 +1,338 @@
+namespace('agt.geom')
+
+# Public: A `Circle` object is defined by a radius, a position
+# and a rotation.
+#
+# ```coffeescript
+# circle = new Circle 80, 100, 100, 0
+# circle = new Circle radius: 80, x: 100, y: 100, rotation: 0
+# ```
+#
+# <script>window.exampleKey = 'circle'</script>
+# <script>drawGeometry(exampleKey, {highlight: true})</script>
+#
+# When conforming to the [Geometry]{agt.geom.Geometry} interface such as the
+# [points]{agt.geom.Geometry::points} method the `Circle` class
+# use approximations based on the number of ` segments` defined on the circle.
+#
+# ### Included Mixins
+#
+# - {agt.geom.Geometry}
+# - {agt.geom.Intersections}
+# - {agt.geom.Path}
+# - {agt.geom.Surface}
+# - [agt.mixins.Cloneable](../../../files/mixins/cloneable.coffee.html)
+# - [agt.mixins.Equatable](../../../files/mixins/equatable.coffee.html)
+# - [agt.mixins.Formattable](../../../files/mixins/formattable.coffee.html)
+# - [agt.mixins.Memoizable](../../../files/mixins/memoizable.coffee.html)
+# - [agt.mixins.Parameterizable](../../../files/mixins/parameterizable.coffee.html)
+# - [agt.mixins.Sourcable](../../../files/mixins/sourcable.coffee.html)
+class agt.geom.Circle
+  @include agt.mixins.Equatable('x','y','radius','rotation')
+  @include agt.mixins.Formattable('Circle','x','y','radius','rotation')
+  @include agt.mixins.Parameterizable('circleFrom', radius: 1, x: 0, y: 0, rotation: 0, segments: 36)
+  @include agt.mixins.Sourcable('agt.geom.Circle', 'radius', 'x', 'y', 'rotation', 'segments')
+  @include agt.mixins.Cloneable()
+  @include agt.mixins.Memoizable
+  @include agt.geom.Geometry
+  @include agt.geom.Surface
+  @include agt.geom.Path
+  @include agt.geom.Intersections
+
+  ### Public ###
+
+  # The general intersections algorithm for circles with non-circle
+  # geometries.
+  #
+  # <script>drawShapeIntersections(exampleKey, 'rectangle')</script>
+  #
+  # geom1 - The first [Geometry]{agt.geom.Geometry}.
+  # geom2 - The second [Geometry]{agt.geom.Geometry}.
+  # block - The iterator {Function} to call with the found intersections.
+  @eachIntersections: (geom1, geom2, block) ->
+    [geom1, geom2] = [geom2, geom1] if geom2.classname?() is 'Circle'
+    points = geom2.points()
+    length = points.length
+    output = []
+
+    for i in [0..length-2]
+      sv = points[i]
+      ev = points[i+1]
+
+      return if geom1.eachLineIntersections sv, ev, block
+
+  # The specific algorithm for circle with circle intersections.
+  #
+  # <script>drawShapeIntersections(exampleKey, exampleKey)</script>
+  #
+  # geom1 - The first `Circle`.
+  # geom2 - The second `Circle`.
+  # block - The iterator {Function} to call with the found intersections.
+  @eachCircleCircleIntersections: (geom1, geom2, block) ->
+    if geom1.equals geom2
+      for p in geom1.points()
+        return if block.call this, p
+    else
+      r1 = geom1.radius
+      r2 = geom2.radius
+      p1 = geom1.center()
+      p2 = geom2.center()
+      d = p1.distance(p2)
+      dv = p2.subtract(p1)
+      radii = r1 + r2
+
+      return if d > radii
+      return block.call this, p1.add(dv.normalize(r1)) if d is radii
+
+      a = (r1*r1 - r2*r2 + d*d) / (2*d)
+      h = Math.sqrt(r1*r1 - a*a)
+      hv = new agt.geom.Point h * (p2.y - p1.y) / d,
+                              -h * (p2.x - p1.x) / d
+
+      p = p1.add(dv.normalize(a)).add(hv)
+      block.call this, p
+
+      p = p1.add(dv.normalize(a)).add(hv.scale(-1))
+      block.call this, p
+
+  # Registers the fast intersections iterators for the Circle class
+  iterators = agt.geom.Intersections.iterators
+  iterators['Circle'] = Circle.eachIntersections
+  iterators['CircleCircle'] = Circle.eachCircleCircleIntersections
+
+  # Creates a new circle instance.
+  #
+  # radius - The radius {Number} or a circle-like {Object}.
+  # x - The {Number} position of the circle center on the x axis.
+  # u - The {Number} position of the circle center on the y axis.
+  # rotation - The rotation {Number} of the circle in radians.
+  # segments - The {Number} of segments when drawing the circle.
+  constructor: (radius, x, y, rotation, segments) ->
+    {@radius,@x,@y,@rotation,@segments} = @circleFrom radius, x, y, rotation, segments
+
+  # Returns the center of the circle.
+  #
+  # <script>drawGeometry(exampleKey, {center: true})</script>
+  #
+  # Returns a [Point]{agt.geom.Point}.
+  center: -> new agt.geom.Point @x, @y
+
+  # Returns the top-most coordinate of the circle shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'top')</script>
+  #
+  # Returns a {Number}.
+  top: -> @y - @radius
+
+  # Returns the bottom-most coordinate of the circle shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'bottom')</script>
+  #
+  # Returns a {Number}.
+  bottom: -> @y + @radius
+
+  # Returns the left-most coordinate of the circle shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'left')</script>
+  #
+  # Returns a {Number}.
+  left: -> @x - @radius
+
+  # Returns the right-most coordinate of the circle shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'right')</script>
+  #
+  # Returns a {Number}.
+  right: -> @x + @radius
+
+  # Adds the passed-in [Point]{agt.geom.Point} to the position
+  # of this circle.
+  #
+  # <script>drawTransform(exampleKey, {type: 'translate', args: [50, 0], width: 150})</script>
+  #
+  # x - A {Number} for the x coordinate or a point-like {Object}.
+  # y - A {Number} for the y coordinate if the first argument
+  #     was also a number.
+  #
+  # Returns this [Circle]{agt.geomCircle}.
+  translate: (x, y) ->
+    {x,y} = agt.geom.Point.pointFrom x, y
+
+    @x += x
+    @y += y
+    this
+
+  # Adds the passed-in rotation to the current circle rotation.
+  #
+  # The rotation of a circle defines at which angle the circle perimeter
+  # starts. In consequences it affects its triangulation, its path properties
+  # and in general every methods that deals with position on the perimeter.
+  #
+  # <script>drawTransform(exampleKey, {type: 'rotate', args: [Math.PI/ 3]})</script>
+  #
+  # rotation - The rotation {Number}.
+  #
+  # Returns this [Circle]{agt.geomCircle}.
+  rotate: (rotation) ->
+    @rotation += rotation
+    this
+
+  # Scales the circle by multiplying its radius by the passed-in `scale`.
+  #
+  # <script>drawTransform(exampleKey, {type: 'scale', args: [0.6]})</script>
+  #
+  # scale - The scale {Number} to apply to the circle.
+  #
+  # Returns this [Circle]{agt.geomCircle}.
+  scale: (scale) ->
+    @radius *= scale
+    this
+
+  # Returns the circle points as approximated using the current `segments`
+  # of the circle.
+  #
+  # <script>drawGeometryPoints(exampleKey, 'points')</script>
+  #
+  # Returns an {Array}.
+  points: ->
+    step = Math.PI * 2 / @segments
+    @pointAtAngle(n * step) for n in [0..@segments]
+
+  # Returns the triangles forming the circle as approximated using
+  # the current `segments` of the circle.
+  #
+  # <script>drawGeometry(exampleKey, {triangles: true})</script>
+  #
+  # Returns an {Array} of [Triangles]{agt.geom.Triangle}.
+  triangles: ->
+    return @memoFor 'triangles' if @memoized 'triangles'
+
+    triangles = []
+    points = @points()
+    center = @center()
+    for i in [1..points.length-1]
+      triangles.push new agt.geom.Triangle center, points[i-1], points[i]
+
+    @memoize 'triangles', triangles
+
+  # Always returns `true`.
+  #
+  # Returns a {Boolean}.
+  closedGeometry: -> true
+
+  # Iterates over all intersections between the vector formed by the `a` and `b`
+  # [Points]{agt.geom.Point} and the current circle.
+  #
+  # <script>drawLineIntersections(exampleKey)</script>
+  #
+  # a - The starting [Points]{agt.geom.Point} of the vector.
+  # b - The ending [Points]{agt.geom.Point} of the vector.
+  # block - The iterator {Function} to call with the found intersections.
+  eachLineIntersections: (a, b, block) ->
+    c = @center()
+
+    _a = (b.x - a.x) * (b.x - a.x) +
+         (b.y - a.y) * (b.y - a.y)
+    _b = 2 * ((b.x - a.x) * (a.x - c.x) +
+              (b.y - a.y) * (a.y - c.y))
+    cc = c.x * c.x +
+         c.y * c.y +
+         a.x * a.x +
+         a.y * a.y -
+         2 * (c.x * a.x + c.y * a.y) - @radius * @radius
+    deter = _b * _b - 4 * _a * cc
+
+    if deter > 0
+      e = Math.sqrt deter
+      u1 = ( - _b + e ) / (2 * _a )
+      u2 = ( - _b - e ) / (2 * _a )
+      unless ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1))
+        if 0 <= u2 and u2 <= 1
+          return if block.call this, agt.geom.Point.interpolate a, b, u2
+
+        if 0 <= u1 and u1 <= 1
+          return if block.call this, agt.geom.Point.interpolate a, b, u1
+
+  # Returns the [Point]{agt.geom.Point} on the perimeter of the circle
+  # at the given `angle`.
+  #
+  # angle - The angle {Number}.
+  #
+  # <script>drawGeometry(exampleKey, {angle: true})</script>
+  #
+  # Returns a [Point]{agt.geom.Point}.
+  pointAtAngle: (angle) ->
+    new agt.geom.Point @x + Math.cos(@rotation + angle) * @radius,
+                       @y + Math.sin(@rotation + angle) * @radius
+
+  # Returns the surface {Number} of this circle.
+  #
+  # Returns a {Number}.
+  acreage: -> @radius * @radius * Math.PI
+
+  # Returns `true` when the given point is contained in the circle.
+  #
+  # In the example below all the green points on the screen represents
+  # coordinates that are contained in the circle.
+  #
+  # <script>drawGeometry(exampleKey, {contains: true})</script>
+  #
+  # x - A {Number} for the x coordinate or a point-like {Object}.
+  # y - A {Number} for the y coordinate if the first argument
+  #     was also a number.
+  #
+  # Returns a {Boolean}.
+  contains: (x, y) ->
+    pt = agt.geom.Point.pointFrom x, y, true
+
+    @center().subtract(pt).length() <= @radius
+
+  # Returns a randomly generated point within the circle perimeter.
+  #
+  # <script>drawGeometry(exampleKey, {surface: true})</script>
+  #
+  # random - An optional [Random]{agt.random.Random} instance to use instead
+  #          of the default `Math` random method.
+  #
+  # Returns a [Point]{agt.geom.Point}.
+  randomPointInSurface: (random) ->
+    unless random?
+      random = new agt.random.Random new agt.random.MathRandom
+
+    pt = @pointAtAngle random.random(Math.PI * 2)
+    center = @center()
+    dif = pt.subtract center
+    center.add dif.scale Math.sqrt random.random()
+
+  # Returns the length {Number} of the circle perimeter.
+  #
+  # Returns a {Number}.
+  length: -> @radius * Math.PI * 2
+
+  # Returns a [Point]{agt.geom.Point} on the circle perimeter using
+  # a {Number} between `0` and `1`.
+  #
+  # <script>drawGeometry(exampleKey, {paths: [0, 1/3, 2/3]})</script>
+  #
+  # n - A {Number} between `0` and `1`a {Number} between `0` and `1`.
+  #
+  # Returns a [Point]{agt.geom.Point}.
+  pathPointAt: (n) -> @pointAtAngle n * Math.PI * 2
+
+  # {Delegates to: agt.geom.Geometry.drawPath}
+  drawPath: (context) ->
+    context.beginPath()
+    context.arc @x, @y, @radius, 0, Math.PI * 2
+
+  # Generates the memoization key for this instance's state.
+  #
+  # For a circle, a memoized value will be invalidated whenever one of the
+  # following properties changes:
+  # - x
+  # - y
+  # - radius
+  # - rotation
+  # - segments
+  #
+  # Returns a {String}.
+  memoizationKey: -> "#{@radius};#{@x};#{@y};#{@rotation};#{@segments}"