agt 0.0.1

data/app/assets/javascripts/agt/random/seeds/linear_congruential.coffee

@@ -0,0 +1,23 @@
+namespace('agt.random')
+# Public:
+class agt.random.LinearCongruential
+  @include agt.mixins.Cloneable('seed')
+  @include agt.mixins.Sourcable('chancejs.LinearCongruential','seed')
+  @include agt.mixins.Formattable('LinearCongruential','seed')
+
+  ### Public ###
+
+  constructor: (@seed=1) ->
+  plantSeed: (@seed=1) ->
+
+  get: ->
+    tmp = @seed
+    q = tmp
+    q = q << 1
+    p = tmp << 32
+    m = p + q
+    if m & 0x80000000
+      m = m & 0x7fffffff
+      m++
+    @seed = m
+    m / 0x80000000

data/app/assets/javascripts/agt/random/seeds/math_random.coffee

@@ -0,0 +1,9 @@
+namespace('agt.random')
+# Public:
+class agt.random.MathRandom
+  @include agt.mixins.Cloneable()
+  @include agt.mixins.Sourcable('chancejs.MathRandom')
+  @include agt.mixins.Formattable('MathRandom')
+
+  # Public:
+  get: -> Math.random()

data/app/assets/javascripts/agt/random/seeds/mersenne_twister.coffee

@@ -0,0 +1,42 @@
+namespace('agt.random')
+# Public:
+class agt.random.MersenneTwister
+  @include agt.mixins.Cloneable('seed')
+  @include agt.mixins.Sourcable('chancejs.MersenneTwister','seed')
+  @include agt.mixins.Formattable('MersenneTwister','seed')
+
+  ### Public ###
+
+  constructor: (seed=0) ->
+    @mt = Array 623
+    @z = 0
+    @y = 0
+
+    @plantSeed seed
+
+  plantSeed: (seed=0) ->
+    @mt[0] = seed
+    @mt[i] = ((0x10dcd * @mt[i-1]) + 1) & 0xFFFFFFFF for i in [1..623]
+
+  get: ->
+    @generateNumbers() if @z >= 623
+    @extractNumber(@z++) / 0x80000000
+
+  ### Internal: ###
+
+  generateNumbers: ->
+    @z = 0
+    for i in [0..623]
+      @y = 0x80000000 & @mt[i] + 0x7FFFFFFF & (@mt[(i + 1) % 623])
+
+      if @y % 2 is 0
+        @mt[i] = @mt[(i + 397) % 623] ^ (@y >> 1)
+      else
+        @mt[i] = @mt[(i + 397) % 623] ^ (@y >> 1) ^ 0x9908B0DF
+
+  extractNumber: (i) ->
+    @y = @mt[i]
+    @y ^= (@y >> 11)
+    @y ^= (@y << 7) & 0x9d2c5680
+    @y ^= (@y << 15) & 0xefc60000
+    @y ^= (@y >> 18)

data/app/assets/javascripts/agt/random/seeds/no_random.coffee

@@ -0,0 +1,12 @@
+namespace('agt.random')
+# Public:
+class agt.random.NoRandom
+  @include agt.mixins.Cloneable('seed')
+  @include agt.mixins.Sourcable('chancejs.NoRandom','seed')
+  @include agt.mixins.Formattable('NoRandom','seed')
+
+  ### Public ###
+
+  constructor: (@seed=0) ->
+
+  get: -> @seed

data/app/assets/javascripts/agt/random/seeds/paul_houle.coffee

@@ -0,0 +1,19 @@
+namespace('agt.random')
+# Original Implementation License:
+#
+# The Central Randomizer 1.3 (C) 1997 by Paul Houle (paul@honeylocust.com)
+# See:  http://www.honeylocust.com/javascript/randomizer.html
+
+# Public:
+class agt.random.PaulHoule
+  @include agt.mixins.Cloneable('seed')
+  @include agt.mixins.Sourcable('chancejs.PaulHoule','seed')
+  @include agt.mixins.Formattable('PaulHoule','seed')
+
+  ### Public ###
+
+  constructor: (@seed) ->
+
+  get: ->
+    @seed = (@seed * 9301 + 49297) % 233280
+    @seed / 233280.0

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

@@ -0,0 +1,272 @@
+# Public: Use a `Signal` object wherever you need to dispatch an event.
+# A `Signal` is a dispatcher that have only one channel.
+#
+# Signals are generally defined as property of an object. And
+# their name generally end with a past tense verb, such as in:
+#
+# ```coffeescript
+# myObject.somethingChanged = new Signal
+# ```
+class agt.Signal
+
+  ### Public ###
+
+  # Creates a new `Signal` instance.
+  # Optionally, a signal can have a specific signature.
+  # A signature is a collection of argument names such:
+  #
+  # ```coffeescript
+  # positionChanged = new Signal 'target', 'position'
+  # ```
+  #
+  # If a signature is passed to a signal, every listener
+  # added to the signal must then match the signature.
+  #
+  # ```coffeescript
+  # # will be registered
+  # positionChanged.add (target, position) ->
+  #
+  # # will be registered too
+  # positionChanged.add (target, position, callback) ->
+  #
+  # # will not be registered
+  # positionChanged.add () -> # will throw an error
+  # ```
+  #
+  # In the case of an asynchronous listener, the callback argument
+  # is not considered as being part of the signature.
+  constructor: (@signature...) ->
+    @listeners = []
+    # The `asyncListeners` property stores the number of asynchronous
+    # listeners to use a synchronous dispatch when equal to 0.
+    @asyncListeners = 0
+
+  # Registers a listener for this signal to be called with
+  # the provided context.
+  # The context is the object that can be accessed through `this`
+  # inside the listener function body.
+  #
+  # An optional `priority` argument allow you to force
+  # an order of dispatch for a listener.
+  #
+  # Signals listeners can be asynchronous, in that case the last
+  # argument of the listener must be named `callback`. An async
+  # listener blocks the dispatch loop until the callback function
+  # passed to the listener is triggered.
+  #
+  # ```coffeescript
+  # # sync listener
+  # signal.add (a, b, c) ->
+  #
+  # # async listener
+  # signal.add (a, b, c, callback) -> callback()
+  # ```
+  #
+  # A listener can be registered several times, but only
+  # if the context object is different each time.
+  #
+  # In other words, the following is possible:
+  #
+  # ```coffeescript
+  # listener = ->
+  # context = {}
+  # myObject.signal.add listener
+  # myObject.signal.add listener, context
+  # ```
+  #
+  # When the following is not:
+  #
+  # ```coffeescript
+  # listener = ->
+  # myObject.signal.add listener
+  # myObject.signal.add listener
+  # ```
+  #
+  # listener - The {Function} to call when a signal is emitted.
+  # context - The `this` {Object} to call the function with.
+  # priority - A priority {Number}, the higher the priority the sooner
+  #            the listener will be called in the dispatch loop.
+  add: (listener, context, priority=0) ->
+    @validate listener
+
+    if not @registered listener, context
+      @listeners.push [listener, context, false, priority]
+      @asyncListeners++ if @isAsync listener
+
+      # Listeners are sorted according to their order each time
+      # a new listener is added.
+      @sortListeners()
+
+  # Registers a listener for only one call.
+  #
+  # All the others rules are the same. So you can't add
+  # the same listener/context couple twice through the two methods.
+  #
+  # listener - The {Function} to call when a signal is emitted.
+  # context - The `this` {Object} to call the function with.
+  # priority - A priority {Number}, the higher the priority the sooner
+  #            the listener will be called in the dispatch loop.
+  addOnce: (listener, context, priority = 0) ->
+    @validate listener
+    if not @registered listener, context
+      @listeners.push [listener, context, true, priority]
+      @asyncListeners++ if @isAsync listener
+      @sortListeners()
+
+  # Removes a listener from this signal, but only with the context that
+  # was registered with it.
+  #
+  # In this regards, avoid to register listeners without a context.
+  # If later in the application a context is forgotten or invalid
+  # when removing a listener from this signal, the listener
+  # without context will end up being removed.
+  #
+  # listener - The {Function} to remove from this signal.
+  # context - The `this` {Object} that was registered with the listener.
+  remove: (listener, context) ->
+    if @registered listener, context
+      @asyncListeners-- if @isAsync listener
+      @listeners.splice @indexOf(listener, context), 1
+
+  # Removes all listeners at once.
+  #
+  # ```coffeescript
+  # signal.removeAll()
+  # ```
+  removeAll: ->
+    @listeners = []
+    @asyncListeners = 0
+
+  # Internal: `indexOf` returns the position of the listener/context couple
+  # in the listeners array.
+  indexOf: (listener, context) ->
+    return i for [l,c],i in @listeners when listener is l and context is c
+    -1
+
+  # Returns true if the passed-in listener have been registered with the
+  # specified context in this signal.
+  #
+  # listener - The listener {Function} to verify.
+  # context - The context {Object} registered with the listener.
+  #
+  # Returns a {Boolean}.
+  registered: (listener, context) ->
+    @indexOf(listener, context) isnt -1
+
+  # Returns true if the signal has listeners.
+  #
+  # Returns a {Boolean}.
+  hasListeners: -> @listeners.length isnt 0
+
+  # Internal: The listeners are sorted according to their `priority`.
+  # The higher the priority the lower the listener will be
+  # in the call order.
+  sortListeners: ->
+    return if @listeners.length <= 1
+    @listeners.sort (a, b) ->
+      [pA, pB] = [a[3], b[3]]
+
+      if pA < pB then 1 else if pB < pA then -1 else 0
+
+  # Internal: Throws an error if the passed-in listener's signature
+  # doesn't match the signal's one.
+  #
+  # ```coffeescript
+  # signal = new Signal 'a', 'b', 'c'
+  # signal.validate () -> # false
+  # signal.validate (a,b,c) -> # true
+  # signal.validate (a,b,c,callback) -> # true
+  # ```
+  validate: (listener) ->
+    if @signature.length > 0
+      re = /[^(]+\(([^)]+)\).*$/m
+      listenerSignature = Function::toString.call(listener).split('\n').shift()
+      signature = listenerSignature.replace(re, '$1')
+      args = signature.split /\s*,\s*/g
+
+      args.shift() if args[0] is ''
+      args.pop() if args[args.length-1] is 'callback'
+
+      s1 = @signature.join()
+      s2 = args.join()
+
+      m = "The listener #{listener} doesn't match the signal's signature #{s1}"
+      throw new Error m if s2 isnt s1
+
+  # Returns `true` if the passed-in `listener` is asynchronous.
+  #
+  # ```coffeescript
+  # signal.isAsync(->) # false
+  # signal.isAsync((callback) ->) # true
+  # ```
+  #
+  # listener - The listner {Function} to test.
+  #
+  # Returns a {Boolean}.
+  isAsync: (listener) ->
+    Function::toString.call(listener).indexOf('callback)') != -1
+
+  # Dispatch a signal to the signal listeners.
+  # Signals are dispatched to all the listeners. All the arguments
+  # passed to the dispatch become the signal's message.
+  #
+  # ```coffeescript
+  # signal.dispatch this, true
+  # ```
+  #
+  # Listeners registered for only one call will be removed after
+  # the call.
+  #
+  # Optionally you can pass a callback argument to the dispatch function.
+  # In that case, the callback must be the last argument passed to the
+  # `dispatch` function.  This function will be called at the end
+  # of the dispatch, allowing to execute code after all listeners,
+  # even asynchronous, have been triggered.
+  #
+  # ```coffeescript
+  # signal.dispatch this, true, ->
+  #     # all listeners have finish their execution
+  # ```
+  #
+  # **Note:** As the dispatch function will automatically consider
+  # the last argument as the callback if its type is `function`, you should
+  # avoid using function as the sole argument or as the last argument
+  # for a listener. If that case occurs, consider either re-arranging the
+  # arguments order or using a value object to carry the function.
+  #
+  # args - The arguments to dispatch with the signal.
+  # callback - A {Function} to callback when all listeners have been notified.
+  dispatch: (args..., callback)->
+    unless typeof callback is 'function'
+      args.push callback
+      callback = null
+
+    listeners = @listeners.concat()
+    # If at leat one listener is async, the whole dispatch process is async
+    # otherwise the fast route is used.
+    if @asyncListeners > 0
+      next = (callback) =>
+        if listeners.length
+          [listener, context, once, priority] = listeners.shift()
+
+          if @isAsync listener
+            listener.apply context, args.concat =>
+              @remove listener, context if once
+              next callback
+          else
+            listener.apply context, args
+            @remove listener, context if once
+            next callback
+        else
+          callback?()
+
+      next callback
+    else
+      # The fast route is just a loop over the listeners.
+      # At that point, if your listener do async stuff, it will
+      # not prevent the dispatching until it's done.
+      for [listener, context, once, priority] in listeners
+        listener.apply context, arguments
+        @remove listener, context if once
+
+      callback?()

data/app/assets/javascripts/agt/sprites/animation.coffee

@@ -0,0 +1,13 @@
+namespace('agt.sprites')
+
+# Public:
+class agt.sprites.Animation
+  constructor: (@image,
+                @width, @height,
+                @rowStart=0, @rowEnd=0,
+                @colStart=0, @colEnd=0
+                @durations) ->
+    @durations = (1000 / 24 for i in [@colStart..@colEnd]) unless @durations?
+    @rowLength = @rowEnd - @rowStart + 1
+    @colLength = @colEnd - @colStart + 1
+    @length = @rowLength * @colLength

data/app/assets/javascripts/agt/sprites/sprite.coffee

@@ -0,0 +1,30 @@
+namespace('agt.sprites')
+
+# Public:
+class agt.sprites.Sprite
+  constructor: (@animation) ->
+    @position = new agt.geom.Point
+    @center = new agt.geom.Point
+    @frame = 0
+    @time = 0
+
+  animate: (bias) ->
+    duration = @animation.durations[@frame]
+    if @time > duration
+      @frame = (@frame + 1) % @animation.length
+      @time = @time % duration
+    @time += bias
+
+  render: (context) ->
+    animation = @animation
+    col = @frame % animation.colLength
+    row = (@frame - col) / animation.colLength
+    clipX = (animation.colStart + col) * animation.width
+    clipY = (animation.rowStart + row) * animation.height
+
+    x = @position.x - @center.x
+    y = @position.y - @center.y
+
+    context.drawImage animation.image,
+                      clipX, clipY, animation.width, animation.height,
+                      x, y, animation.width, animation.height

data/app/assets/javascripts/agt/widgets/hash.coffee

@@ -0,0 +1,36 @@
+namespace('agt.widgets')
+
+# Public:
+class agt.widgets.Hash
+  constructor: ->
+    @clear()
+
+  clear: ->
+    @keys = []
+    @values = []
+
+  set: (key, value) ->
+    if @hasKey key
+      index = @keys.indexOf key
+      @keys[index] = key
+      @values[index] = value
+    else
+      @keys.push key
+      @values.push value
+
+  get: (key) -> @values[ @keys.indexOf key ]
+
+  getKey: (value) -> @keys[ @values.indexOf value ]
+
+  hasKey: (key) -> @keys.indexOf(key) > 0
+
+  unset: (key) ->
+    index = @keys.indexOf key
+    @keys.splice index, 1
+    @values.splice index, 1
+
+  each: (block) -> @values.forEach block
+
+  eachKey: (block) -> @keys.forEach block
+
+  eachPair: (block) -> @keys.forEach (key) => block? key, @get key