ceml 0.7.13 → 0.8.0

data/lib/ceml/models/bundle.rb

@@ -0,0 +1,64 @@
+module CEML
+  class Bundle < Struct.new(:id)
+    include Redis::Objects
+    value :castables, :marshal => true
+
+    def clear_from_all_rooms(player_id)
+      Audition.new(player_id).clear_from_all_rooms
+    end
+
+    def find_castables(stanza_name = nil)
+      return castables.value unless stanza_name
+      return [castables.value.find{ |c| c.stanza_name == stanza_name }]
+    end
+
+    def all_rooms
+      find_castables.map(&:all_rooms).flatten.uniq
+    end
+
+    def reset
+      all_rooms.each(&:clear)
+    end
+
+    def rooms_for_player(player, stanza_name = nil)
+      roomnames = find_castables(stanza_name).map{ |c| c.waiting_rooms_for_player(player, stanza_name) }.flatten.uniq
+      roomnames.map{ |r| WaitingRoom.new(r) }
+    end
+
+    def join_running_incident?(player, stanza_name = nil)
+      rooms_for_player(player, stanza_name).each do |room|
+        if incident_id = room.audition_for_incidents(player)
+          return incident_id
+        end
+      end
+      false
+    end
+
+    def cast_player?(player, stanza_name = nil)
+      incident_id  = gen_code
+      find_castables(stanza_name).each do |castable|
+        if cast = castable.cast_player?(incident_id, player, stanza_name)
+          i = IncidentModel.new(incident_id)
+          i.bytecode.value = castable.bytecode
+          i.add_castings(cast.castings)
+          return incident_id
+        end
+      end
+      false
+    end
+
+    def absorb?(player, stanza_name = nil)
+      x = join_running_incident?(player, stanza_name)
+      puts "X1: #{x.inspect}"
+      return x if x
+      x = cast_player?(player, stanza_name)
+      puts "X2: #{x.inspect}"
+      x
+    end
+
+    def register_in_rooms(player, stanza_name = nil)
+      Audition.new("#{player[:id]}").list_in_rooms(rooms_for_player(player, stanza_name))  ##{gen_code}:
+    end
+
+  end
+end

data/lib/ceml/models/cast.rb

@@ -0,0 +1,108 @@
+module CEML
+  RoleSpec = Struct.new :name, :tagspec, :range
+
+  # this contains the logic of building and approving a valid cast
+  # for an await statement, starting with a seed first_guy
+  class Cast
+    extend Forwardable
+    attr_reader :castings
+    def_delegators :@castable, :type, :timewindow, :radius, :matching, :roles
+    def_delegators :@castings, :[]
+    def initialize(castable, first_guy)
+      @castable = castable
+      @castings = Hash.new{ |h,k| h[k] = Set.new }
+      cast first_guy
+    end
+
+    def room(role)
+      casted_count = @castings[role.name].size
+      [role.range.max - casted_count, 0].max
+    end
+
+    def affinity role, guy
+      casted_count = @castings[role.name].size
+      needed =  [role.range.min - casted_count, 0].max
+      allowed = [role.range.max - casted_count, 0].max
+
+      return [-1, -1, -1 ] unless role.tagspec =~ guy and allowed > 0
+      [ role.tagspec.with.size, -needed, -allowed ]
+    end
+
+    def <=>(other)
+      castings <=> other.castings
+    end
+
+    def cast guy
+      return if included? guy or not self =~ guy
+      best_role = roles.max_by{ |role| affinity(role, guy) }
+      return if affinity(best_role, guy)[0] == -1
+      @castings[best_role.name] << guy
+      guy[:roles] = best_role.name.to_sym
+    end
+
+    def included? guy
+      folks.any?{ |fellow| fellow[:id] == guy[:id] }
+    end
+
+    def launchable?
+      case type
+      when :accept
+        roles.any?{ |role| castings[role.name].size >= 1 }
+      when :await
+        roles.all?{ |role| castings[role.name].size >= role.range.min }
+      end
+    end
+
+    def folks
+      castings.values.map(&:to_a).flatten
+    end
+
+    def player_ids
+      folks.map{ |p| p[:id] }
+    end
+
+    def star
+      folks.first
+    end
+
+    def closes_at
+      return nil unless star && timewindow
+      star[:ts] + timewindow
+    end
+
+    def matchings
+      return {} unless star
+      Hash[ *matching.map{ |k| [k, star[:matchables][k]] } ]
+    end
+
+    def circle
+      return nil unless star && radius
+      llr = star[:lat] && star[:lng] && [star[:lat], star[:lng], radius]
+      ll && Circle.new(*llr)
+    end
+
+    def tagspecs
+      roles.map(&:tagspec).uniq
+    end
+
+    def =~(c)
+      (!closes_at or closes_at < Time.unix) and
+      (!circle or circle.contains?(c[:lat], c[:lng])) and
+      (matchings.each{ |k,v| c[:matchables][k] == v }) and
+      (tagspecs.any?{ |ts| ts =~ c })
+    end
+  end
+
+  class Circle < Struct.new :lat, :lng, :radius
+    def center; Geokit::LatLng(lat, lng); end
+    def contains?(*ll)
+      center.distance_to(Geokit::LatLng(*ll), :meters) <= radius
+    end
+  end
+
+  class Tagspec < Struct.new :with, :without
+    def =~(c)
+      with.all?{ |t| (c[:tags]||[]).include?(t) } and without.all?{ |t| !(c[:tags]||[]).include?(t) }
+    end
+  end
+end

data/lib/ceml/models/castable.rb

@@ -0,0 +1,81 @@
+module CEML
+  class Castable < Struct.new :type, :stanza_name, :matching, :radius, :timewindow, :roles, :bytecode
+
+    def cast_player?(incident_id, player, seeded=false)
+      room_ids = hot_waiting_rooms_given_player(player, seeded)
+      hotties = Audition.from_rooms(room_ids)
+      # puts "hotties are... #{hotties.inspect} from rooms #{room_ids.inspect}"
+      hot_players = hotties.keys.map{ |id| Player.new(id).data.value } + [player]
+      # puts "casting from #{hot_players.inspect}"
+      if cast = cast_from(hot_players)
+        puts "...cast with cast #{cast.player_ids.inspect}"
+        audition_ids = (cast.player_ids & hotties.keys).map{ |id| hotties[id] }
+        puts "consuming #{audition_ids.inspect}"
+        if Audition.consume(audition_ids, room_ids)
+          # post audition signs in waiting rooms for remaining parts
+          with_open_roles(cast) do |idx, role, count|
+            waiting_rooms_to_watch(role, cast).each do |room|
+              room.list_job(incident_id, idx, role.name, count)
+            end
+          end
+          return cast
+        else
+          sleep 0.02
+          return cast_player?(incident_id, player)
+        end
+      end
+      return
+    end
+
+    def waiting_rooms_for_player(player, seeded=false)
+      result = []
+      result.concat([*player[:seeded]]) if player[:seeded]
+      result.concat player[:tags] if player[:tags] unless seeded
+      # result << 'generic'
+      result
+    end
+
+    def hot_waiting_rooms_given_player(player, seeded=false)
+      rooms = waiting_rooms_for_player(player, seeded)
+      roles.each{ |r| rooms.concat(["#{stanza_name}:#{r.name}", *r.tagspec.with]) }
+      rooms << "#{stanza_name}:*"
+      # rooms << 'generic'
+      rooms.uniq
+    end
+
+    def waiting_rooms_to_watch(role, cast)
+      # skip for now: radius, timewindow, matching, general
+      result = []
+      if stanza_name
+        result << "#{stanza_name}:#{role.name}"
+        result << "#{stanza_name}:*"
+      end
+      if !role.tagspec.with.empty?
+        result.concat role.tagspec.with
+      end
+      # result << 'generic'
+      result.map{ |id| WaitingRoom.new(id) }
+    end
+
+    def all_rooms
+      roles.map{ |r| waiting_rooms_to_watch(r, {}) }.flatten
+    end
+
+    def with_open_roles(cast)
+      roles.each_with_index do |role, i|
+        count = cast.room(role)
+        next unless count > 0
+        yield i, role, count
+      end
+    end
+
+    # an O(n*^2) alg for now.  can do much better
+    def cast_from guys
+      # see if we can build a cast out of them and bid on the casts
+      possible_casts = guys.map{ |guy| Cast.new self, guy }.select(&:star)
+      guys.each{ |guy| possible_casts.each{ |cast| cast.cast guy }}
+      result = possible_casts.detect(&:launchable?)
+      result
+    end
+  end
+end

data/lib/ceml/{incident.rb → models/incident.rb}

@@ -21,29 +21,50 @@ module CEML
     end
 
     def rolematch(specified_roles)
-      expanded = roles.map{ |r| r == :agent ? [:agent, :agents] : r }.flatten.concat([:both, :all, :everyone])
-      not (expanded & specified_roles).empty?
+      expanded = roles.map{ |r| r == :agent ? [:agent, :agents] : r }.flatten.concat([:both, :all, :everyone, :them, :either])
+      not (expanded & [*specified_roles]).empty?
     end
 
+    def log state
+      p = @this
+      instr = seq[pc]
+      guyroles = roles.to_a - [:everyone, :players, :them, :all, :either, :each, :agents, :both]
+      instr ||= []
+
+      puts "[#{id}] #{p[:id]}(#{guyroles}) ##{pc} #{state} -- #{instr[1]}/#{instr[0]} -- #{instr[2].inspect}"
+    end
+
+
     def run(players, &blk)
       @players = players
       @callback = blk
 
       loop do
-        players = @players.select{ |p| !p[:released] }
-        # puts "playing with #{players.map{|p|p[:id]}}"
+        players = @players
         advanced = false
         players.each do |p|
           @this = p
-          # puts "trying #{@this[:id]}"
-          next unless instr = seq[pc]
+          instr = seq[pc]
+          unless instr = seq[pc]
+            log 'off schedule'
+            @players.delete(p)
+            cb :released
+            next
+          end
           instr = instr.dup
-          if not rolematch(instr.shift)
+          rolespec = instr.shift
+          if not rolematch(rolespec)
+            log "skipping[#{rolespec}]"
             this[:pc]+=1
             advanced = true
           else
             instr << role_info if instr.first == :start  #tmp hack
-            next unless send(*instr)
+            if send(*instr)
+              log 'completed'
+            else
+              log 'blocked'
+              next
+            end
             cb(*instr)
             this[:pc]+=1
             advanced = true
@@ -67,17 +88,22 @@ module CEML
       end
     end
 
+    def players_with_role(role)
+      if role
+        @players.select{ |p| p[:roles].include? role }
+      else
+        @players.reject{ |p| p == this }
+      end
+    end
 
     def expand(role, var)
       case role
-      when 'his', 'her', 'their', 'my', 'its';    return qs_answers[var]
+      when 'his', 'her', 'their', 'my', 'its', 'your';    return qs_answers[var]
       when 'world', 'game', 'exercise', 'group';  return (cb :world, var)
       when 'somebody', 'someone', 'buddy', 'teammate';  role = nil
       end
       role = role.to_sym if role
-      @players.each do |p|
-        next if p == this
-        next if role and not p[:roles].include? role
+      players_with_role(role).each do |p|
         value = (p[:qs_answers]||{})[var] and return value
       end
       nil
@@ -102,6 +128,16 @@ module CEML
       cb :said, params.merge(:said => x)
     end
 
+    def seed x
+      x[:rolemap].each do |pair|
+        if rolematch(pair[:from].to_sym)
+          cb :seeded, :target => x[:target], :role => pair[:to]
+          break
+        end
+      end
+      true
+    end
+
     def start(x); true; end
     def finish; true; end
 
@@ -116,9 +152,9 @@ module CEML
       true
     end
 
-    def sync
+    def sync q
       this[:synced] = pc
-      return true if @players.all?{ |p| p[:synced] == pc }
+      return true if players_with_role(q[:role]).all?{ |p| p[:synced] == pc }
     end
 
     def ask_q q
@@ -141,6 +177,12 @@ module CEML
       true
     end
 
+    def pick q
+      choices = q[:value].split(/\s+\-\s+/)
+      qs_answers[q[:key]] ||= choices.sort_by{ rand }.first
+      true
+    end
+
     def send_msg a
       text = interpolate(a[:text]) or return false
       say :message, :msg => text
@@ -180,8 +222,14 @@ module CEML
 
     def release x
       return true if x[:cond] and not expectation(*x[:cond])
-      this[:released] = x[:tag]
+      @players.delete(this)
       cb :released, x[:tag]
+      true
+    end
+
+    def replace x
+      return true if x[:cond] and not expectation(*x[:cond])
+      # TODO: implement replace
       false
     end
 

data/lib/ceml/models/incident_model.rb

@@ -0,0 +1,100 @@
+class Hash
+  def like(*syms)
+    syms.inject({}) { |h, k| h[k] = self[k] if self[k]; h }
+  end
+end
+
+module CEML
+  PLAYER_THREAD_FIELDS = [ :pc, :continue_at, :synced ]
+  # :received, :recognized, :last_answer, :last_answer_recognized
+
+  class IncidentModel < Struct.new(:id)
+    include Redis::Objects
+    lock :running
+    value :bytecode,        :marshal => true
+    value :data,            :marshal => true
+    hash_key :player_roles, :marshal => true
+
+    def add_castings(castings)
+      castings.each do |rolename, folks|
+        folks.each do |player|
+          Player.new(player[:id]).touch(id)
+          player_roles[player[:id]] = [rolename.to_sym]
+          puts "ADDED(#{id}) #{player[:id]} = #{rolename.to_sym}"
+        end
+      end
+    end
+
+    def release(player_id)
+      puts "Releasing player #{player_id} from incident #{id}"
+      Player.new(player_id).clear_incident(id)
+      player_roles.delete(player_id)
+    end
+
+    def expire
+      # TODO: remove casting calls from waiting rooms
+      bytecode.clear
+      data.clear
+    end
+
+    def self.run_latest(cb_obj)
+      t = CEML.clock - 1
+      ids = redis.zrangebyscore 'ceml_continue_at', 0, t
+      ids.each{ |id| self.new(id).run(cb_obj) }
+      redis.zremrangebyscore 'ceml_continue_at', 0, t
+    end
+
+    def run(cb_obj)
+      raise unless String === id
+      # puts "RUNNING(#{id})"
+      # running_lock.lock do
+        metadata, player_data = *data.value
+        metadata    ||= { :id => id }
+        player_data ||= {}
+        puts "[#{id}] Player data loaded: #{player_data.inspect}"
+        players = []
+
+        puts "[#{id}] Player roles: #{player_roles.all.inspect}"
+        player_roles.each do |player_id, roles|
+          puts "#{id}: #{player_id.inspect} => #{roles.inspect}, #{player_data[player_id].inspect}"
+          player = { :id => player_id, :roles => Set.new(roles) }
+          player[:roles] << :agents << :players << :both << :all << :each << :everyone << :them << :either
+          player.merge! player_data[player_id] if player_data[player_id]
+          p = Player.new(player_id)
+          stored_player = p.data.value
+          msg = p.message.value
+          player.merge! msg if msg
+          player.merge! stored_player if stored_player
+          players << player
+        end
+
+        CEML::Incident.new(bytecode.value, id).run(players) do |player, meth, what|
+          case meth.to_sym when :released, :finish, :replace
+            release(player[:id])
+          end
+          meth = "player_#{meth}"
+          # cb_obj.log "[#{id}] #{meth}: #{player[:id]} #{what.inspect}"
+          if cb_obj.respond_to? meth
+            metadata.update :player => player, :players => players, :id => id
+            result = cb_obj.send(meth, metadata, what)
+            metadata.delete :player
+            metadata.delete :players
+            result
+          end
+        end
+
+        players.each do |p|
+          Player.new(p[:id]).message.value = p.like(:received, :recognized, :situation)
+          player_data[p[:id]] = p.like *PLAYER_THREAD_FIELDS
+        end
+        puts "Player data saving: #{player_data.inspect}"
+        data.value = [metadata, player_data]
+
+        if next_run = players.map{ |p| p[:continue_at] }.compact.min
+          redis.zadd 'ceml_continue_at', next_run, id
+        end
+      # end
+    end
+
+  end
+end

data/lib/ceml/models/incident_role_slot.rb

@@ -0,0 +1,16 @@
+module CEML
+
+  class IncidentRoleSlot < Struct.new(:incident_id, :role, :max)
+    def id; "#{incident_id}:#{role}"; end
+    include Redis::Objects
+    counter :casted
+
+    def reserve_spot!
+      casted.incr{ |val| val <= max }
+    end
+
+    def full?
+      casted.value >= max
+    end
+  end
+end

data/lib/ceml/models/player.rb

@@ -0,0 +1,80 @@
+module CEML
+  class Player < Struct.new(:id)
+    include Redis::Objects
+    lock :updating
+    value :data,    :marshal => true
+    value :message, :marshal => true
+    sorted_set :current_incidents
+
+    def touch(incident_id)
+      current_incidents[incident_id] = Time.now.to_i
+    end
+
+    def reset
+      Audition.new(id).clear_from_all_rooms
+      data.clear
+      message.clear
+      current_incidents.clear
+    end
+
+    def top_incident_id
+      current_incidents.last
+    end
+
+    def top_incident
+      if iid = top_incident_id
+        IncidentModel.new(iid)
+      end
+    end
+
+    def clear_incident(id)
+      current_incidents.delete(id)
+    end
+
+    def self.update bundle_id, player, cb_obj, &blk
+      player[:bundle_id] = player[:squad_id] = bundle_id
+      new(player[:id].to_s).update player, cb_obj, &blk
+    end
+
+    def clear_answers
+      updating_lock.lock do
+        value = data.value || {}
+        value.delete(:qs_answers)
+        value.delete(:received)
+        data.value = value
+      end
+    end
+
+    MSG_PARAMS = [:received, :recognized, :situation]
+
+    def split player
+      new_message = player.like(*MSG_PARAMS)
+      MSG_PARAMS.each{ |p| player.delete(p) }
+      return new_message, player
+    end
+
+    def merge_new_player_data player
+      updating_lock.lock do
+        old_value = data.value || {}
+        new_value = old_value.merge player
+        new_value[:qs_answers] = (old_value[:qs_answers]||{}).merge(player[:qs_answers] || {})
+        # puts "SAVING DATA: #{new_value.inspect}"
+        data.value = new_value
+      end
+    end
+
+    def update player, cb_obj
+      player = player.dup
+      # puts "UPDATING player id #{id} with #{player.inspect}"
+      new_message, player = split(player)
+      merge_new_player_data(player)
+      cmd = new_message[:recognized]
+      if cmd and cb_obj.recognize_override(cmd, new_message, player, self)
+        message.delete
+      else
+        message.value = new_message
+        yield player if block_given?
+      end
+    end
+  end
+end

data/lib/ceml/models/queue.rb

@@ -0,0 +1,12 @@
+module CEML
+  class Queue
+    def id; 'ceml_q'; end
+    include Redis::Objects
+    list :calls, :marshal => true
+
+    def run(klass)
+      p = klass.new
+      while call = calls.shift; p.send(*call); end
+    end
+  end
+end

data/lib/ceml/models/waiting_room.rb

@@ -0,0 +1,40 @@
+module CEML
+
+  class WaitingRoom < Struct.new(:id)
+    include Redis::Objects
+    set :waiting_auditions
+    set :waiting_incident_roles
+
+    def clear
+      waiting_auditions.each do |audition_id|
+        Audition.new(audition_id).clear_from_all_rooms(id)
+      end
+      waiting_incident_roles.clear
+    end
+
+    def audition_for_incidents(player)
+      # puts "auditioning #{player[:id]} for incidents in room #{id}"
+      waiting_incident_roles.members.each do |key|
+        incident_id, idx, role, count = *key.split(':')
+        # puts "checking against #{incident_id}: #{role}"
+        count = count.to_i
+        role_slot = IncidentRoleSlot.new(incident_id, role, count)
+        next unless role_slot.reserve_spot!
+        waiting_incident_roles.delete(key) if role_slot.full?
+        IncidentModel.new(role_slot.incident_id).add_castings({ role_slot.role => [ player ] })
+        return role_slot.incident_id
+      end
+      return false
+    end
+
+    def list_job(incident_id, idx, rolename, count)
+      waiting_incident_roles << [incident_id, idx, rolename, count].join(':')
+    end
+
+    def add(audition_id)
+      puts "adding #{audition_id} to waiting room #{id.inspect}"
+      waiting_auditions << audition_id
+    end
+  end
+
+end

data/lib/ceml/models.rb

@@ -0,0 +1,16 @@
+require 'redis'
+require 'redis/objects'
+
+Redis::Objects.redis = Redis.new
+
+require 'ceml/models/cast'
+require 'ceml/models/castable'
+require 'ceml/models/incident'
+require 'ceml/models/audition'
+require 'ceml/models/incident_model'
+require 'ceml/models/incident_role_slot'
+require 'ceml/models/player'
+require 'ceml/models/waiting_room'
+require 'ceml/models/queue'
+require 'ceml/models/bundle'
+