monkeymusic 0.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gem 'hallon'
+gem 'em-websocket'
+gem 'json'
+gem 'rack'

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    em-websocket (0.5.0)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0.5.3)
+    eventmachine (1.0.3)
+    ffi (1.8.1)
+    hallon (0.18.2)
+      ffi (~> 1.8)
+      spotify (~> 12.5.1)
+      weak_observable (~> 1.0)
+    http_parser.rb (0.5.3)
+    json (1.7.7)
+    libspotify (12.1.51.3)
+    rack (1.5.2)
+    ref (1.0.4)
+    spotify (12.5.1)
+      ffi (~> 1.0, >= 1.0.11)
+      libspotify (~> 12.1.51)
+    weak_observable (1.0.1)
+      ref (~> 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  em-websocket
+  hallon
+  json
+  rack

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 Ryan Bates
+              2013 Oscar Söderlund
+ 
+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.markdown

@@ -0,0 +1,38 @@
+Monkey Music
+============
+
+This is the runtime for a programming contest, it's a work in progress.
+
+To test-drive:
+
+    ./bin/monkeymusic --user users/poscar.yaml --level levels/testlevel.rb --player-file p1 --player-name p1 --player-file p1 --player-name p2
+
+Rules
+-----
+
+### Which monkey gets to move first?
+
+Every round, all monkeys are put into a Fisher-Yates shuffled array, and
+the monkeys will be allowed to move in order of increasing index.
+
+Input
+-----
+
+One line with one positive integer, id, that identifies your monkey.
+One line with two positive integers, w, h. The width and the 
+height of the level.
+h lines with w comma-separated strings each. Each string represents a
+space in the level.
+
+A space can contain the following:
+
+A monkey, on the form M#id, the letter M followed by a hash followed by the id of a monkey.
+A basket, on the form B#id, the letter B followed by a hash followed by
+A track URI, on the form spotify:track:XXXXXXXXXXXXXXX.
+the id of the monkey the basket belongs to.
+A palm tree, on the form P.
+
+Output
+------
+
+One of the characters ['N','W','E','S'] followed by a line-break '\n'.

data/bin/monkeymusic

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/monkey_music'
+
+runner = MonkeyMusic::Runner.new(ARGV)
+runner.run

data/levels/testlevel.rb

@@ -0,0 +1,28 @@
+carrying_capacity 3
+metadata_requests_per_turn 2
+max_turns 100
+
+legend({ 
+  "1" => Monkey.player(1),
+  "2" => Monkey.player(2),
+  "X" => Track.worth(-2),
+  "x" => Track.worth(-1),
+  "l" => Track.worth(1),
+  "t" => Track.worth(2),
+  "T" => Track.worth(3),
+  "U" => User,
+})
+
+layout <<LAYOUT
+...........
+..x........
+...........
+.......T...
+1..........
+...t......U
+2..........
+.......l...
+...........
+..X........
+...........
+LAYOUT

data/levels/testlevel_maze.rb

@@ -0,0 +1,24 @@
+width 25
+height 11
+max_turns 200
+carrying_capacity 100
+
+legend({ 
+  "1" => Monkey,
+  "!" => Track,
+  "#" => Wall,
+})
+
+layout <<LAYOUT
+#########################
+#!    #        #       !#
+###   ######   #  #######
+#        #        #     #
+#  ###   ######   #     #
+#  #! #           #  #  #
+#  #  #  ###      #  #  #
+#  #        #  #  #1 #  #
+#  ######   ##########  #
+# !#                    #
+#########################
+LAYOUT

data/levels/the_last_crusade.rb

@@ -0,0 +1,21 @@
+# In this level, the monkeys ability to navigate a maze and pick
+# the best out of many tracks is tested. Do not choose poorly...
+
+width 20
+height 10
+capacity 1
+
+legend({
+  "T" => Tube,
+  "M" => Monkey,
+  "s" => Track,
+  "#" => Wall,
+})
+
+layout <<EOS
+T..#.....#.....#...s
+...#..#..#..#..#...s
+.M.#..#..#..#..#...s
+...#..#..#..#..#...s
+......#.....#......s
+EOS

data/lib/monkey_music/game.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+module MonkeyMusic
+  class Game
+
+    def initialize(level, players, ui)
+      @level = level
+      @players = players
+      @ui = ui
+    end
+
+    def start
+      @level.max_turns.times do
+        if @level.complete?
+          break
+        end
+        @ui.update(@level)
+        # Query players for moves
+        @players.each { |p| p.query_move! }
+        # Move players in random order
+        @players.shuffle.each { |p| p.move! }
+      end
+      @ui.update(@level)
+    end
+
+  end
+end

data/lib/monkey_music/level.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module MonkeyMusic
+  class Level
+    attr_accessor :width, :height, :max_turns
+    attr_reader :players
+    attr_reader :user
+    
+    def initialize(players, user)
+      @players = players
+      @user = user
+      @width = 0
+      @height = 0
+      @units = []
+    end
+    
+    def add(unit, x, y)
+      unit.place!(self, x, y)
+      unit.assign_id
+      @units << unit
+    end
+    
+    def at(x, y)
+      @units.detect { |u| u.at?(x, y) }
+    end
+
+    def empty?(x, y)
+      at(x, y).nil?
+    end
+
+    def complete?
+      (@units.detect { |u| u.kind_of? Track }).nil? &&
+        (@players.detect { |p| p.monkey.carrying.count > 0 }).nil?
+    end
+
+    def remove(unit)
+      @units.reject! { |u| u == unit }
+    end
+    
+    def out_of_bounds?(x, y)
+      x < 0 || y < 0 || x > @width-1 || y > @height-1
+    end
+
+    def accessible?(x, y)
+      not out_of_bounds?(x, y) && empty?(x, y)
+    end
+
+    def load_from_file(file)
+      LevelLoader.new(self).instance_eval(IO.read(file))
+      self
+    end
+
+    def to_s
+      rows = []
+      rows << " " + ("=" * @width)
+      @height.times do |y|
+        row = ["|"]
+        @width.times do |x|
+          unit = at(x, y)
+          row << if unit then unit.to_s else ' ' end
+        end
+        row << "|"
+        rows << row.join
+      end
+      rows << " " + ("=" * @width)
+      rows.join("\n")
+    end
+
+    def serialize
+      rows = []
+      @height.times do |y|
+        row = []
+        @width.times do |x|
+          unit = at(x, y)
+          row << if unit then unit.serialize else '_' end
+        end
+        rows << row.join(",")
+      end
+      rows.join("\n")
+    end
+
+    def as_json
+      {
+        :width => @width,
+        :height => @height,
+        :units => @units,
+      }.to_json
+    end
+
+  end
+end

data/lib/monkey_music/level_loader.rb

@@ -0,0 +1,64 @@
+module MonkeyMusic
+  #
+  # LevelLoader defines a DSL for building levels in a ruby file
+  #
+  class LevelLoader
+    def initialize(level)
+      @level = level
+      @legend = {}
+    end
+
+    def max_turns(max_turns)
+      @level.max_turns = max_turns
+    end
+
+    def metadata_requests_per_turn(n)
+      @metadata_requests_per_turn = n
+    end
+
+    def carrying_capacity(capacity)
+      @level.players.each { |p| p.monkey.capacity = capacity }
+    end
+
+    def legend(legend)
+      @legend = legend
+    end
+
+    def layout(layout)
+      # Transform layout into x y indexed array
+      units = (layout.lines.map { |l| l.chomp.split(//) }).transpose
+      @level.width = units[0].length
+      @level.height = units.length
+      # Add units from layout to level
+      @level.height.times do |y|
+        @level.width.times do |x|
+          curr_character = units[x][y]
+          unit = parse_character(curr_character)
+          @level.add(unit, x, y) if unit
+        end
+      end
+    end
+
+    private
+
+    def parse_character(character)
+      klass = @legend[character]
+      if klass
+        unit = if (klass <= Monkey)
+          klass.from_players(@level.players)
+        elsif klass <= Track
+          klass.from_user(@level.user)
+        elsif klass == User
+          @level.user
+        else
+          klass.new
+        end
+        if unit
+          unit.character = character
+          unit
+        end
+      end
+    end
+
+  end
+end

data/lib/monkey_music/player.rb

@@ -0,0 +1,41 @@
+module MonkeyMusic
+  class Player
+    attr_accessor :monkey
+    
+    def initialize(file)
+      @file = file
+      @monkey = Monkey.new()
+    end
+
+    def query_move!
+      IO.popen(@file, "r+") do |io|
+        io.puts @monkey.serialize
+        io.puts @monkey.remaining_capacity
+        io.puts @monkey.level.width
+        io.puts @monkey.level.height
+        io.puts @monkey.level.serialize
+        move = io.gets
+        @next_move = parse_move(move) if move
+      end
+    end
+
+    def parse_move(s)
+      case s.chomp
+      when "N" then :north
+      when "W" then :west
+      when "E" then :east
+      when "S" then :south
+      end
+    end
+
+    def move!
+      @monkey.move! @next_move if @next_move
+      @next_move = nil
+    end
+
+    def to_s
+      "#{@monkey.name}: #{@file}"
+    end
+
+  end
+end

data/lib/monkey_music/recommendation_loader.rb

@@ -0,0 +1,91 @@
+require 'hallon'
+
+module MonkeyMusic
+  class RecommendationLoader
+
+    def initialize(loaded_toplists, load_factor = 5)
+      @loaded_toplists = loaded_toplists
+      @load_factor = load_factor
+    end
+
+    def load_for_user!(user)
+      @user = user
+      puts "Loading recommendations from album toplist..."
+      load_recommendations_from_albums!
+      puts "Loading recommendations from artist toplist..."
+      load_recommendations_from_artists!
+      puts "Loading recommendations from track toplist albums..."
+      load_recommendations_from_top_track_albums!
+      puts "Loading recommendations from track toplist..."
+      load_recommendations_from_already_heard!
+      puts "Loading recommendations from disliked artists..."
+      load_recommendations_from_disliked!
+    end
+
+    private
+
+    def load_recommendations_from_albums!
+      @loaded_toplists[:top_albums].each do |album|
+        puts "Browsing #{album.name}..."
+        browse = album.browse
+        browse.load unless browse.loaded?
+        browse.tracks.first(@load_factor).each do |rec|
+          @user.recommendations << parse_track(rec)
+        end
+      end
+    end
+
+    def load_recommendations_from_artists!
+      @loaded_toplists[:top_artists].each do |artist|
+        puts "Browsing #{artist.name}..."
+        browse = artist.browse(:no_albums)
+        browse.load unless browse.loaded?
+        browse.top_hits.first(@load_factor).each do |rec|
+          @user.recommendations << parse_track(rec)
+        end
+      end
+    end
+
+    def load_recommendations_from_top_track_albums!
+      @loaded_toplists[:top_track_albums].each do |album|
+        puts "Browsing #{album.name}..."
+        browse = album.browse
+        browse.load unless browse.loaded?
+        browse.tracks.first(@load_factor).each do |rec|
+          @user.recommendations << parse_track(rec)
+        end
+      end
+    end
+
+    def load_recommendations_from_already_heard!
+      @loaded_toplists[:top_tracks].each do |track|
+        @user.recommendations << parse_track(track)
+      end
+    end
+
+    def load_recommendations_from_disliked!
+      @loaded_toplists[:disliked].each do |artist|
+        puts "Browsing #{artist.name}..."
+        browse = artist.browse(:no_albums)
+        browse.load unless browse.loaded?
+        browse.top_hits.first(@load_factor).each do |rec|
+          @user.recommendations << parse_track(rec)
+        end
+      end
+    end
+
+    def parse_track(track)
+      album = track.album.load
+      artist = track.artist.load
+      user_track = Track.new
+      user_track.uri = track.to_link.to_str
+      user_track.name = track.name
+      user_track.artist = artist.name
+      user_track.album = album.name
+      user_track.popularity = track.popularity
+      user_track.year = album.release_year
+      user_track
+    end
+
+  end
+end

data/lib/monkey_music/runner.rb

@@ -0,0 +1,169 @@
+require 'optparse'
+
+module MonkeyMusic
+  class Runner
+
+    def initialize(arguments)
+      @arguments = arguments
+      @opt_parser = OptionParser.new
+      @players = []
+      @delay = 1
+      init_parser(@opt_parser)
+    end
+
+    def run
+      @opt_parser.parse!
+      if generate_user?
+        # Create user
+        user = User.new
+        # Connect to libspotify
+        Hallon.load_timeout = 0
+        session = Hallon::Session.initialize(IO.read(@spotify_appkey_file))
+        session.login!(@spotify_account, @spotify_password)
+        # Load toplists
+        puts "Loading toplists from #{@toplist_file}..."
+        toplist_loader = ToplistLoader.new(@toplist_file)
+        toplist_loader.load_for_user!(user)
+        # Generate recommendations
+        puts "Loading recommendations..."
+        loaded_toplists = toplist_loader.loaded_toplists
+        recommendation_loader = RecommendationLoader.new(loaded_toplists)
+        recommendation_loader.load_for_user!(user)
+        # Disconnect from libspotify
+        session.logout!
+        # Evaluate recommendations
+        puts "Evaluating recommendations..."
+        score_system = ScoreSystem.new
+        score_system.evaluate_user_recommendations!(user)
+        # Dump and print the user
+        File.open(@out_file, 'w') do |f|
+          f.write(user.dump)
+        end
+        puts "====="
+        puts "DONE!"
+        puts "====="
+        puts "Loaded tracks:"
+        user.recommendations.group_by(&:multiplier).sort.each do |k,v| 
+          puts "#Multiplier #{k}:\t#{v.length}"
+        end
+        exit
+      elsif not game_is_playable?
+        puts @opt_parser
+        exit
+      end
+      # Load user
+      user = User.new
+      user.load_from_file(@user_file)
+      # Load level
+      level = Level.new(@players, user)
+      level.load_from_file(@level_file)
+      ## Initialize UI
+      if browser_ui?
+        print "Using browser UI. Press the enter key to start game. "
+        gets
+        puts "Starting game..."
+        ui = BrowserUI.new(@delay)
+      else
+        ui = ConsoleUI.new(@delay)
+      end
+      ## Start game
+      @game = Game.new(level, @players, ui)
+      @game.start
+    end
+
+    private
+
+    def generate_user?
+      (defined? @toplist_file) &&
+        (defined? @out_file) &&
+        (defined? @spotify_appkey_file) &&
+        (defined? @spotify_account) &&
+        (defined? @spotify_password)
+    end
+
+    def game_is_playable?
+      (defined? @user_file) &&
+        (defined? @level_file) &&
+        (not @players.empty?)
+    end
+
+    def browser_ui?
+      @browser_ui == true
+    end
+
+    def init_parser(opts)
+      opts.banner = 'Usage: monkeymusic [options]'
+
+      opts.on('-l',
+              '--level LEVEL',
+              'The level to play.') do |file|
+        @level_file = File.join(Dir.getwd, file)
+      end
+      
+      opts.on('-u',
+              '--user USER',
+              'The user the players will recommend music for.') do |user|
+        @user_file = File.join(Dir.getwd, user)
+      end
+
+      opts.on('-p',
+              '--player FILE',
+              'The path to a player program.') do |file|
+        player_file = File.join(Dir.getwd, file)
+        @players << Player.new(player_file)
+      end
+
+      opts.on('-n',
+              '--player-name NAME', 
+              'Set the name of the last entered player.') do |name|
+        @players[-1].monkey.name = name unless @players.empty?
+      end
+
+      opts.on('-d', '--delay DELAY', OptionParser::DecimalNumeric,
+              'The delay (in seconds) between each round.') do |delay|
+        @delay = delay
+      end
+
+      opts.on('-g',
+              '--generate TOPLIST_FILE',
+              'Generate a user from a toplist file.') do |user|
+        @toplist_file = File.join(Dir.getwd, user)
+      end
+
+      opts.on('-o',
+              '--out OUT_FILE',
+              'The file to dump a generated user to.') do |file|
+        @out_file = File.join(Dir.getwd, file)
+      end
+
+      opts.on('-k', 
+              '--app-key KEY', 
+              'Path to libspotify application key.') do |key|
+        @spotify_appkey_file = File.join(Dir.getwd, key)
+      end
+
+      opts.on('-a', 
+              '--account ACCOUNT', 
+              'Username for a Spotify premium account.') do |account|
+        @spotify_account = account
+      end
+
+      opts.on('-w', '--password PASSWORD', 
+              'Password for a Spotify premium account.') do |password|
+        @spotify_password = password
+      end
+
+      opts.on('-b', '--browser-ui', 
+              'View the game through the browser instead of the console.') do |password|
+        @browser_ui = true
+      end
+
+      opts.on_tail('-h',
+                   '--help', 
+                   'Show this message.') do 
+        puts opts
+        exit
+      end
+    end
+  end
+end