monkeymusic 0.0.1

data/lib/monkey_music/score_system.rb

@@ -0,0 +1,37 @@
+module MonkeyMusic
+  class ScoreSystem
+
+    def evaluate_user_recommendations!(user)
+      @user = user
+      @user.recommendations.each { |track| evaluate!(track) }
+    end
+
+    def evaluate!(track)
+      multiplier = 0
+      if @user.toplists[:top_tracks].include? track.name
+        multiplier = -1
+      elsif @user.toplists[:disliked].include? track.artist
+        multiplier = -2
+      else
+        if @user.toplists[:top_albums].include? track.album
+          multiplier += 1
+        end
+        if @user.toplists[:top_artists].include? track.artist
+          multiplier += 1
+        end
+        if @user.toplists[:top_track_albums].include? track.album
+          multiplier += 1
+        end
+      end
+      track.multiplier = multiplier
+      track.value = 4**multiplier.abs * sign(multiplier)
+    end
+
+    private
+
+    def sign(num)
+      num < 0 ? -1 : 1
+    end
+
+  end
+end

data/lib/monkey_music/toplist_loader.rb

@@ -0,0 +1,68 @@
+require 'hallon'
+
+module MonkeyMusic
+  class ToplistLoader
+    attr_reader :loaded_toplists
+
+    def initialize(toplist_file)
+      @toplist_file = IO.read(toplist_file)
+      @toplists = {}
+    end
+
+    def load_for_user!(user)
+      @user = user
+      # Load toplists URI:s from file
+      self.instance_eval(@toplist_file)
+      # Load toplist contents from libspotify
+      load_toplists!
+      load_top_track_albums!
+    end
+
+    private
+
+    # User toplist DSL
+
+    def toplist(type, uri)
+      @toplists[type] = uri
+    end
+
+    # Toplist loading
+
+    def load_toplists!
+      @loaded_toplists = {}
+      @toplists.each do |type, uri|
+        @loaded_toplists[type] = load_from_list(type, uri)
+        @user.toplists[type] = parse_toplist(@loaded_toplists[type])
+      end
+    end
+
+    def load_top_track_albums!
+      @loaded_toplists[:top_track_albums] = 
+        @loaded_toplists[:top_tracks].map(&:album).each(&:load)
+      @user.toplists[:top_track_albums] = 
+        parse_toplist(@loaded_toplists[:top_track_albums])
+    end
+
+    def load_from_list(type, uri)
+      playlist = Hallon::Playlist.new(uri).load
+      tracks = playlist.tracks.to_a
+      tracks.each(&:load)
+      if type == :top_tracks
+        tracks
+      elsif type == :top_artists || type == :disliked
+        tracks.map(&:artist).each(&:load)
+      elsif type == :top_albums
+        tracks.map(&:album).each(&:load)
+      end
+    end
+
+    def parse_toplist(list)
+      result = []
+      list.each do |item|
+        result << item.name
+      end
+      result
+    end
+
+  end
+end

data/lib/monkey_music/ui/browser_ui.rb

@@ -0,0 +1,36 @@
+require 'em-websocket'
+require 'json'
+require 'rack'
+
+module MonkeyMusic
+  class BrowserUI
+
+    def initialize(delay)
+      @delay = delay || 1
+      puts "Initializing websockets..."
+      Thread.new {
+        EM.run {
+          EM::WebSocket.run(:host => "0.0.0.0", :port => 3000) do |ws|
+            @ws = ws
+            ws.onopen do |handshake|
+            end
+
+            ws.onclose do
+            end
+
+            ws.onmessage do |msg|
+            end
+          end
+        }
+      }
+      sleep 1 # TODO: Asynchronous acknowledge that ui is ready
+      puts "Websockets initialized!"
+    end
+
+    def update(level)
+      @ws.send(level.as_json) if @ws
+      sleep @delay
+    end
+
+  end
+end

data/lib/monkey_music/ui/console_ui.rb

@@ -0,0 +1,31 @@
+module MonkeyMusic
+  class ConsoleUI
+
+    def initialize(delay)
+      @delay = delay || 1
+    end
+
+    def msg(msg)
+      puts "\e[H\e[2J"
+      puts "\n"*5
+      puts " "*10 + msg
+      puts "\n"*5
+    end
+    
+    def update(level)
+      # Clear screen
+      puts "\e[H\e[2J"
+      # Level
+      puts level.to_s
+      # Score
+      puts "\n"
+      puts "="*10
+      puts "\n"
+      level.players.each do |player|
+        puts "#{player.monkey.name}: #{player.monkey.score}"
+        puts "{ #{"0"*player.monkey.carrying.count}#{"_"*player.monkey.remaining_capacity} }\n"
+      end
+      sleep @delay
+    end
+  end
+end

data/lib/monkey_music/units/base.rb

@@ -0,0 +1,71 @@
+module MonkeyMusic
+  class Base
+    attr_accessor :x, :y, :character
+    attr_reader :level, :id
+
+    @@curr_id = 0
+
+    def assign_id
+      @id = @@curr_id
+      @@curr_id += 1
+    end
+
+    def place!(level, x, y)
+      @level = level
+      @x, @y = x, y
+    end
+
+    def move!
+      # To be overriden
+    end
+
+    def at?(x, y)
+      @x == x && @y == y
+    end
+
+    def distance_to(unit)
+      (@x - unit.x).abs + (@y - unit.y).abs
+    end
+
+    def pos
+      [@x, @y]
+    end
+
+    def direction_of(unit)
+      if (@x - unit.x).abs > (@y - unit.y).abs
+        unit.x > @x ? :east : :west
+      else
+        unit.y > @y ? :south : :north
+      end
+    end
+
+    def to_s
+      @character
+    end
+
+    # As shown to player
+    def serialize
+      to_s
+    end
+
+    def to_json(options = {})
+      { :id => @id,
+        :x => @x,
+        :y => @y,
+        :type => self.class.name.split('::').last
+      }.to_json
+    end
+
+    private
+
+    def translate(x, y, direction)
+      case direction
+      when :north then [x,     y - 1]
+      when :south then [x,     y + 1]
+      when :east  then [x + 1, y    ]
+      when :west  then [x - 1, y    ]
+      end
+    end
+
+  end
+end

data/lib/monkey_music/units/monkey.rb

@@ -0,0 +1,85 @@
+module MonkeyMusic
+  class Monkey < Base
+    attr_accessor :name, :score, :capacity, :character
+    attr_reader :carrying, :facing
+
+    def self.player(number)
+      Class.new Monkey do @player_index = number - 1 end
+    end
+
+    def self.from_players(players)
+      @player_index &&
+        players[@player_index] &&
+        players[@player_index].monkey
+    end
+
+    def initialize
+      @score = 0
+      @capacity = 1
+      @carrying = []
+      @delivered = []
+      @facing = [:west, :east].sample
+    end
+
+    def move!(direction)
+      target = translate(@x, @y, direction)
+      if target_unit = @level.at(*target)
+        # Interact with unit
+        interact_with!(target_unit)
+      else
+        # Face the right direction
+        @facing = case direction
+          when :west then :west
+          when :east then :east
+          else @facing
+        end
+        # Perform move
+        @x, @y = *target if @level.accessible?(*target)
+      end
+    end
+
+    def interact_with!(unit)
+      case unit
+      when Track then pick_up!(unit)
+      when User then deliver!
+      end
+    end
+
+    def pick_up!(unit)
+      if @carrying.count < @capacity
+        @level.remove(unit)
+        @carrying << unit
+      end
+    end
+
+    def deliver!
+      @delivered += @carrying
+      @score += tally(@carrying)
+      @carrying = []
+    end
+
+    def tally(tracks)
+      score = 0
+      tracks.each do |track|
+        score += track.value
+      end
+      score
+    end
+
+    def remaining_capacity
+      (@capacity - carrying.count) || 0
+    end
+
+    def to_json(options = {})
+      { :id => @id,
+        :x => @x,
+        :y => @y,
+        :facing => @facing,
+        :type => self.class.name.split('::').last,
+        :name => @name,
+        :score => @score,
+      }.to_json
+    end
+
+  end
+end

data/lib/monkey_music/units/track.rb

@@ -0,0 +1,33 @@
+module MonkeyMusic
+  class Track < Base
+    attr_accessor :uri, :name, :artist, :album, :popularity, :year,
+      :value, :multiplier
+
+    def self.worth(n)
+      Class.new Track do @worth = n end
+    end
+
+    def self.from_user(user)
+      if @worth
+        user.recommend!(@worth) || user.recommendations.sample
+      else
+        user.recommendations.sample
+      end
+    end
+
+    def serialize
+      @uri
+    end
+
+    def to_json(options = {})
+      { :id => @id,
+        :x => @x,
+        :y => @y,
+        :type => self.class.name.split('::').last,
+        :name => @name,
+        :multiplier => @multiplier,
+        :value => @value,
+      }.to_json
+    end
+  end
+end

data/lib/monkey_music/units/user.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+
+module MonkeyMusic
+  class User < Base
+    attr_accessor :toplists, :recommendations
+
+    def initialize
+      @toplists = {}
+      @recommendations = @remaining_recommendations = []
+    end
+
+    def recommend!(worth)
+      index = @remaining_recommendations.index do |r|
+        r.multiplier == worth
+      end
+      if index
+        @remaining_recommendations.delete_at(index)
+      else
+        @recommendations.find { |r| r.multiplier == worth }
+      end
+    end
+
+    def dump
+      YAML::dump({
+        :toplists => @toplists,
+        :recommendations => @recommendations
+      })
+    end
+
+    def load_from_file(file)
+      data = YAML::load(IO.read(file))
+      @toplists = data[:toplists]
+      @recommendations = data[:recommendations]
+      @remaining_recommendations = @recommendations
+    end
+    
+  end
+end

data/lib/monkey_music/units/wall.rb

@@ -0,0 +1,4 @@
+module MonkeyMusic
+  class Wall < Base
+  end
+end

data/lib/monkey_music.rb

@@ -0,0 +1,20 @@
+$: << File.dirname(__FILE__)
+
+require 'set'
+
+require 'monkey_music/runner'
+require 'monkey_music/game'
+require 'monkey_music/player'
+require 'monkey_music/toplist_loader'
+require 'monkey_music/recommendation_loader'
+require 'monkey_music/score_system'
+require 'monkey_music/level'
+require 'monkey_music/level_loader'
+
+require 'monkey_music/ui/console_ui'
+require 'monkey_music/ui/browser_ui'
+
+require 'monkey_music/units/base'
+require 'monkey_music/units/monkey'
+require 'monkey_music/units/track'
+require 'monkey_music/units/user'

data/users/synth.rb

@@ -0,0 +1,7 @@
+toplist :top_tracks, "spotify:user:poscar%21:playlist:4yIhuHviCmTYjcFqunPxsa"
+
+toplist :top_artists, "spotify:user:poscar%21:playlist:6MjfrIbeCKQMVCU9JQNf1u"
+
+toplist :top_albums, "spotify:user:poscar%21:playlist:1ZXPeNHa8YYvY0VzxRdv3q"
+
+toplist :disliked, "spotify:user:poscar%21:playlist:5IEx3cooSMgrtftvw5B9Ug"