agt 0.0.1

data/app/assets/javascripts/agt/particles/timers/instant.coffee

@@ -0,0 +1,11 @@
+namespace('agt.particles.timers')
+# Public:
+class agt.particles.timers.Instant
+
+  ### Public ###
+
+  prepare: ->
+
+  finished: -> true
+
+  nextTime: -> 0

data/app/assets/javascripts/agt/particles/timers/limited.coffee

@@ -0,0 +1,19 @@
+namespace('agt.particles.timers')
+# Public:
+class agt.particles.timers.Limited
+
+  ### Public ###
+
+  constructor: (@duration=1000, @since=0) ->
+    @time = 0
+    @nextTime = 0
+
+  prepare: (bias, biasInSeconds, time) ->
+    unless @firstTime
+      @nextTime = @since + bias
+      @firstTime = true
+    else
+      @nextTime = bias
+    @time += bias
+
+  finished: -> @time >= @duration

data/app/assets/javascripts/agt/particles/timers/null_timer.coffee

@@ -0,0 +1,11 @@
+namespace('agt.particles.timers')
+# Public:
+class agt.particles.timers.NullTimer
+
+  ### Public ###
+
+  nextTime: 0
+
+  prepare: ->
+
+  finished: -> true

data/app/assets/javascripts/agt/particles/timers/unlimited.coffee

@@ -0,0 +1,9 @@
+namespace('agt.particles.timers')
+# Public:
+class agt.particles.timers.Unlimited extends agt.particles.timers.Limited
+
+  ### Public ###
+
+  constructor: (since) -> super Infinity, since
+
+  finished: -> false

data/app/assets/javascripts/agt/particles/timers/until_death.coffee

@@ -0,0 +1,11 @@
+namespace('agt.particles.timers')
+# Public:
+class agt.particles.timers.UntilDeath
+
+  ### Public ###
+
+  constructor: (@particle) ->
+
+  prepare: (bias, biasInSeconds, time) -> @nextTime = bias
+
+  finished: -> @particle.dead

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

@@ -0,0 +1,214 @@
+# Public: A lightweight implementation of promises.
+class agt.Promise
+
+  ### Public ###
+
+  # Returns an already fulfilled promise with the passed-in `value`.
+  #
+  # value - The promise's value.
+  #
+  # Returns a [Promise]{agt.Promise}.
+  @unit: (value=0) ->
+    new agt.Promise -> value
+
+  # Returns a promise that is fulfilled when all the passed-in have been
+  # fulfilled. The value of all the promised are provided in the returned
+  # promise value.
+  # If one of the promises fails, the returned promise is rejected.
+  #
+  # promises - An {Array} of promises
+  #
+  # Returns a [Promise]{agt.Promise}.
+  @all: (promises) ->
+    promise = new agt.Promise
+    solved = 0
+    results = []
+
+    promises.forEach (p ,i) ->
+      p
+      .then (value) ->
+        solved++
+        results[i] = value
+        promise.resolve results if solved is promises.length
+
+      .fail (reason) ->
+        promise.reject reason
+
+    promise
+
+  # Creates a new Promise.
+  #
+  # factory - The {Function} to call to resolve the created promise.
+  constructor: (@factory) ->
+    @pending = true
+    @started = false
+    @fulfilled = null
+    @value = undefined
+    @timeout = 60000
+    @message = 'Timed out'
+
+    @fulfilledHandlers = []
+    @errorHandlers = []
+    @progressHandlers = []
+
+  # Returns `true` if the promise has not been resolved.
+  #
+  # Returns a {Boolean}.
+  isPending: -> @pending
+
+  # Returns `true` if the promise has been resolved.
+  #
+  # Returns a {Boolean}.
+  isResolved: -> not @pending
+
+  # Returns `true` if the promise has been resolved successfully.
+  #
+  # Returns a {Boolean}.
+  isFulfilled: -> not @pending and @fulfilled
+
+  # Returns `true` if the promise has been resolved by a rejection.
+  #
+  # Returns a {Boolean}.
+  isRejected: -> not @pending and not @fulfilled
+
+  # Registers callbacks to the promise and returns a new Promise that will
+  # be resolved after the `fulfilledHandler` has been called.
+  #
+  # fulfilledHandler - The {Function} to call when the current promise
+  #                    is fulfilled.
+  # errorHandler - The {Function} to call when the current promise has been
+  #                rejected.
+  # progressHandler - The {Function} to call during the promise progress.
+  #                   Note that not all the promise provides informations
+  #                   about their progress.
+  #
+  # Returns a [Promise]{agt.Promise}
+  then: (fulfilledHandler, errorHandler, progressHandler) ->
+    @start() unless @started
+    promise = new agt.Promise
+    f = (value)->
+      try
+        res = fulfilledHandler? value
+      catch err
+        promise.reject err
+        return
+
+      if res?.then?
+        res
+        .then (value) ->
+          promise.resolve value
+        .fail (reason) ->
+          promise.reject reason
+      else
+        promise.resolve res
+
+    e = (reason) ->
+      errorHandler? reason
+      promise.reject reason
+
+    if @pending
+      @fulfilledHandlers.push f
+      @errorHandlers.push e
+      @progressHandlers.push progressHandler if progressHandler?
+    else
+      if @fulfilled
+        f @value
+      else
+        e @reason
+
+    promise
+
+  # Registers a callback for the rejection of the promise.
+  # It's just an alias of:
+  #
+  # ```coffee
+  # promise.then((->), errorHandler)
+  # ```
+  #
+  # errorHandler - The {Function} to call when the current promise has been
+  #                rejected.
+  #
+  # Returns a [Promise]{agt.Promise}.
+  fail: (errorHandler) -> @then (->), errorHandler
+
+  # Binds the passed-in promise to this one so that the promise
+  # is resolved when this promise resolved and hold the same value
+  # or reason of the rejection.
+  #
+  # promise - The [Promise]{agt.Promise} to bind to this promise resolution.
+  #
+  # Returns a [Promise]{agt.Promise}.
+  bind: (promise) ->
+    @then ((res) -> promise.resolve(res)), ((reason) -> promise.reject(reason))
+
+  # Resolves the current promise as fulfilled with the given `value`.
+  #
+  # value - The value to fulfill the promise with.
+  resolve: (@value) ->
+    return unless @pending
+
+    @fulfilled = true
+    @notifyHandlers()
+    @pending = false
+
+  # Resolves the current promise with a rejection.
+  #
+  # reason - The reason for the rejection.
+  reject: (reason) ->
+    return unless @pending
+
+    @reason = reason
+    @fulfilled = false
+    @pending = false
+    @notifyHandlers()
+
+  # Starts the promise by calling its factory function if one was provided.
+  start: ->
+    return if @started
+
+    if @factory?
+      try
+        if @signature(@factory).length is 0
+          @resolve(@factory.call this)
+        else
+          lastTime = new Date()
+
+          f = =>
+            @reject new Error @message if new Date() - lastTime >= @timeout
+            setTimeout f, 10 if @pending
+
+          @factory.call(this, this)
+          f()
+      catch e
+        @reject e
+
+    @started = true
+
+  # Setup a hook to reject the promise automatically after a given duration.
+  #
+  # timeout - The {Number} of milliseconds before the promise is rejected.
+  # message - The message {String} to use for the rejection.
+  rejectAfter: (@timeout, @message) ->
+
+  ### Internal ###
+
+  # Notifies the different callbacks registered on this promise according
+  # to the promise state.
+  notifyHandlers: ->
+    if @fulfilled
+      handler @value for handler in @fulfilledHandlers
+    else
+      handler @reason for handler in @errorHandlers
+
+  # Returns the signature of the passed-in function.
+  #
+  # func - The {Function} for which return the signature.
+  #
+  # Returns an {Array} of the function arguments.
+  signature: (func) ->
+    re = ///
+      ^function
+      (\s+[a-zA-Z_][a-zA-Z0-9_]*)*
+      \s*\(([^\)]+)\)
+      ///
+    re.exec(func.toString())?[2].split(/\s*,\s*/) or []

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

@@ -0,0 +1,100 @@
+namespace('agt.random')
+{floor, round} = Math
+
+# Public: Create a `Random` object whenever you need randomized values
+# of various kind. The `Random` class doesn't provides the random generation
+# itself, it relies on `Seeder` objects, but will use the generated values
+# to produce a wide range of values.
+#
+# ```coffeescript
+# random = new agt.random.Random(new agt.random.MathRandom)
+# ```
+class agt.random.Random
+  @include agt.mixins.Cloneable('generator')
+  @include agt.mixins.Sourcable('agt.random.Random','generator')
+  @include agt.mixins.Formattable('Random','generator')
+
+  ### Public ###
+
+  constructor: (@generator) ->
+
+  get: -> @generator.get()
+
+  boolean: (rate=0.5) -> rate = 0.5 unless 0 <= rate <= 1; @get() < rate
+  bit: (rate=0.5) -> if @boolean rate then 1 else 0
+  sign: (rate=0.5) -> if @boolean rate then 1 else -1
+
+  char: (arg, rangeEnd) ->
+    [arg, rangeEnd] = ['abcdefghijklmnopqrstuvwxyz', null] unless arg?
+    switch typeof arg
+      when 'string'
+        if typeof rangeEnd is 'string'
+          str = ''
+          for n in [arg.charCodeAt(0)..rangeEnd.charCodeAt(0)]
+            str += String.fromCharCode(n)
+          arg = str
+
+        arg.substr @intRandom(arg.length - 1), 1
+
+      when 'number'
+        if typeof rangeEnd is 'number'
+          n = String.fromCharCode floor @inRange arg, rangeEnd
+        else
+          String.fromCharCode @intRandom arg
+
+  inRange: (a, b, c) ->
+    res = a + @random b - a
+    if typeof c is 'number'
+      r = 1 / c
+      res -= res % c unless floor(res * r) is res * r
+
+    res = floor(res * 1000000000) / 1000000000
+    res
+
+  inArray: (array, ratios, summed) ->
+    if array?
+      if ratios?
+        if ratios.length isnt array.length
+          throw new Error 'array and ratios arrays must have the same length'
+        if summed
+          for b,i in ratios
+            if i > 0
+              a = ratios[i-1]
+              if a > b
+                throw new Error 'ratios must be ordered when summed is true'
+
+        if summed
+          last = ratios[ratios.length-1]
+          ratios = ratios.map (n) -> n / last
+        else
+          sum = ratios.reduce (a, b) -> a + b
+          ratios = ratios.map (n) -> n / sum
+          ratios[i] += ratios[i-1] for n,i in ratios when i > 0
+
+        rand = @get()
+        return array[i] for v,i in ratios when rand <= v
+      else
+        array[@intRandom array.length - 1]
+    else
+      null
+
+  in: (a, b, c) ->
+    if arguments.length > 3 then @inArray arguments
+    else
+      switch typeof a
+        when 'number' then @inRange a, b
+        when 'string' then @inArray a, b, c
+        when 'object'
+          if Object::toString.call(a) == '[object Array]'
+            @inArray a, b, c
+          else
+            if a.min? and a.max? then @inRange a.min, a.max, a.step
+        else null
+
+  sort: -> => @intPad 2
+
+  random: (amount) -> @get() * (amount or 1)
+  intRandom: (amount) -> round @random amount
+
+  pad: (amount) -> amount / 2 - @random amount
+  intPad: (amount) -> round @pad amount

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

@@ -0,0 +1,53 @@
+namespace('agt.random')
+# Public:
+class agt.random.LaggedFibonnacci
+  @include agt.mixins.Cloneable('seed')
+  @include agt.mixins.Sourcable('chancejs.LaggedFibonnacci','seed')
+  @include agt.mixins.Formattable('LaggedFibonnacci','seed')
+
+  ### Public ###
+
+  constructor: (seed=0) ->
+    @plantSeed seed
+
+  get: ->
+    uni = @u[@i97] - @u[@j97]
+    uni += 1.0 if uni < 0.0
+
+    @u[@i97] = uni
+
+    @i97 = 96 if --@i97 < 0
+    @j97 = 96 if --@j97 < 0
+    @c -= @cd
+    @c += @cm if @c < 0.0
+    uni -= @c
+    uni += 1.0 if uni < 0.0
+    uni
+
+  plantSeed:(seed=0) ->
+    @u = new Array 97
+    ij = seed / 30082
+    kl = seed - 30082 * ij
+
+    i = ((ij / 177) % 177) + 2
+    j = (ij % 177) + 2
+    k = ((kl / 169) % 178) + 1
+    l = kl % 169
+
+    for ii in [0..96]
+      [s,t] = [0.0, 0.5]
+
+      for jj in [0..23]
+        m = (((i * j) % 179) * k) % 179
+        [i,j,k] = [j,k,m]
+        l = (53 * l + 1) % 169
+        s += t if (l * m) % 64 >= 32
+        t *= 0.5
+
+      @u[ii] = s
+
+    @c = 362436.0 / 16777216.0
+    @cd = 7654321.0 / 16777216.0
+    @cm = 16777213.0 / 16777216.0
+    @i97 = 96
+    @j97 = 32

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

@@ -0,0 +1,16 @@
+namespace('agt.random')
+# Public:
+class agt.random.Linear
+  @include agt.mixins.Cloneable('step')
+  @include agt.mixins.Sourcable('chancejs.Linear','step')
+  @include agt.mixins.Formattable('Linear','step')
+
+  ### Public ###
+
+  constructor: (@step=1000000000) ->
+    @iterator = 0
+
+  get: ->
+    res = @iterator++ / @step
+    @iterator = 0 if @iterator > @step
+    res