foot_stats_simulator 0.0.1 → 0.0.2

data/app/models/simulator_player.rb

@@ -1,9 +1,34 @@
 class SimulatorPlayer < ActiveRecord::Base
+  belongs_to :simulator_team
+
+  def to_foot_stats
+    {
+      '@Id'      => self.source_id,
+      '@Nome'    => self.full_name,
+      '@Apelido' => self.nickname
+    }
+  end
+
+  def self.to_foot_stats
+    # FootStats suck!
+    # Yes, it's stupid, but it's true...
+    # FootStats doesn't return a collection on this...
+    if count == 0
+      nil
+    else
+      if count == 1
+        self.first.to_foot_stats
+      else
+        { 'Equipe' => all.map(&:to_foot_stats) }
+      end
+    end
+  end
+
   def self.dump!
     SimulatorTeam.all.each do |team|
       FootStats::Player.all(team: team.source_id).each do |foot_stats_player|
         player = self.find_or_create_by_source_id foot_stats_player.source_id
-        player.update_attributes foot_stats_player.attributes
+        player.update_attributes foot_stats_player.attributes.merge(simulator_team_id: team.id)
       end
     end
   end

data/app/models/simulator_team.rb

@@ -1,9 +1,27 @@
 class SimulatorTeam < ActiveRecord::Base
+  has_many :simulator_championship_participations
+  has_many :simulator_championships, through: :simulator_championship_participations
+  has_many :simulator_players
+
+  def to_foot_stats
+    {
+      '@Id'     => self.source_id,
+      '@Nome'   => self.full_name,
+      '@Cidade' => self.city,
+      '@Pais'   => self.country
+    }
+  end
+
+  def self.to_foot_stats
+    { 'Equipe' => all.map(&:to_foot_stats) }
+  end
+
   def self.dump!
     SimulatorChampionship.all.each do |championship|
       FootStats::Team.all(championship: championship.source_id).each do |foot_stats_team|
         team = self.find_or_create_by_source_id foot_stats_team.source_id
         team.update_attributes foot_stats_team.attributes
+        SimulatorChampionshipParticipation.find_or_create_by_simulator_team_id_and_simulator_championship_id team.id, championship.id
       end
     end
   end

data/app/models/simulator_timeline.rb

@@ -1,111 +1,103 @@
-class SimulatorTimeline < ActiveRecord::Base
-  belongs_to :match
+# TODO: Handle penalties
+
+class SimulatorTimeline
+  attr_reader :match
 
   attr_accessor :states, :current_period, :current_minute
-  attr_accessor :narration, :home_goals, :home_cards, :home_players, :visitor_goals, :visitor_cards, :visitor_players
+  attr_accessor :narration, :home_goals, :home_cards, :current_home_players, :visitor_goals, :visitor_cards, :current_visitor_players
 
-  def period(period)
-    if block_given?
-      yield Period.new(self, period)
-    else
-      Period.new(self, period_time)
-    end
+  def initialize(match, timeline_name)
+    @match         = match
+    @timeline_path = File.expand_path File.join(FootStatsSimulator.timelines_dir, "#{timeline_name}.rb")
+    load_timeline
   end
 
-  def current_period_time
-    SimulatorMatch::STATUS_SEQUENCE[current_period] || current_period.to_i
+  def timeline_rand(limit = nil)
+    @random.rand limit
   end
 
-  def transitions
-    states = States.new self
-    yield(states)
-    states.set_current
+  def sample(collection)
+    collection[timeline_rand(collection.size)]
   end
 
-  def setup
-    @narration       = []
-    @home_goals      = []
-    @home_cards      = []
-    @home_players    = []
-    @visitor_goals   = []
-    @visitor_cards   = []
-    @visitor_players = []
-    yield(self)
+  def collection_of(n, collection)
+    collecteds = []
+    while collecteds.size < n
+      collected = sample(collection)
+      collecteds << collected unless collecteds.include?(collected)
+    end
+    collecteds
   end
 
-  class States
-    def initialize(timeline)
-      @timeline        = timeline
-      @timeline.states = []
-    end
+  def home_score
+    home_goals.count{ |g| g.type == 'Favor' } + visitor_goals.count{ |g| g.type != 'Favor' }
+  end
 
-    def set_current
-      delta  = (Time.now - @timeline.match.scheduled_start).to_i
-      period = @timeline.states.find{|minute, status| delta > minute }[1]
+  def visitor_score
+    visitor_goals.count{ |g| g.type == 'Favor' } + home_goals.count{ |g| g.type != 'Favor' }
+  end
 
-      @timeline.current_period = period
+  def home_team
+    @match.home_team
+  end
 
-      @timeline.current_minute if period.to_s.match(/(period|prorrogation)/)
-        started_second = @timeline.states.find{ |minute, status| status == period }[0]
-        ((Time.now - @timeline.match.scheduled_start) + started_second).from_now
-      else
-        0
-      end
-    end
+  def visitor_team
+    @match.visitor_team
+  end
 
-    def add_transition(status, time)
-      @timeline.states << [time, status]
-      @timeline.sort!
-    end
+  def home_players
+    @home_players ||= @match.home_simulator_team.simulator_players.order(:source_id)
+  end
 
-    def method_missing(method_name, *args, &block)
-      if SimulatorMatch::STATUS_SEQUENCE[method_name]
-        add_transition(method_name, args.first)
-      else
-        super(method_name, *args, &block)
-      end
-    end
+  def visitor_players
+    @visitor_players ||= @match.visitor_simulator_team.simulator_players.order(:source_id)
   end
 
-  class Period
-    def initialize(timeline, period)
-      @timeline, @period = timeline, period
-    end
+  def all_current_players
+    current_home_players + current_visitor_players
+  end
 
-    def period_time
-      SimulatorMatch::STATUS_SEQUENCE[@period] || @period.to_i
-    end
+  def all_players
+    home_players + visitor_players
+  end
 
-    def at(minute)
-      if block_given?
-        yield Minute.new(@timeline, period_time, @minute)
-      else
-        Minute.new(@timeline, period_time, @minute)
-      end
-    end
+  def update_match
+    @match.update_attributes status:                    current_period,
+                             home_score:                home_score,
+                             home_penalties_score:      nil,
+                             visitor_score:             visitor_score,
+                             visitor_penalties_score:   nil
   end
 
-  class Minute
-    def initialize(timeline, minute)
-      @timeline, @minute = timeline, minute
-    end
+  def transitions(&block)
+    States.new(self, &block)
+  end
 
-    def event(type, *args)
-      [@timeline, @minute, type, args]
+  def period(period)
+    if block_given?
+      yield Period.new(self, period)
+    else
+      Period.new(self, period_time)
     end
+  end
 
-    def add_home_goal(player_source_id, type = 'Favor', reference = nil)
-      @timeline.home_goals << event(:goal, player_source_id, type, reference)
-    end
+  def current_period_time
+    SimulatorMatch::STATUS_SEQUENCE[current_period] || current_period.to_i
+  end
 
-    def add_visitor_goal(player_source_id, type = 'Favor', reference = nil)
-      @timeline.visitor_goals << event(:goal, player_source_id, type, reference)
-    end
+  protected
+  def load_timeline
+    @random = Random.new @match.timeline_random_seed
 
-    def remove_goal(reference)
-      @timeline.home_goals.delete_all do |period, minute, type, *args|
-        type == goal && args[2] == reference
-      end
-    end
+    @states                  = []
+    @narration               = []
+    @home_goals              = []
+    @home_cards              = []
+    @current_home_players    = []
+    @visitor_goals           = []
+    @visitor_cards           = []
+    @current_visitor_players = []
+
+    eval File.read(@timeline_path)
   end
 end

data/app/models/simulator_timeline/card_event.rb

@@ -0,0 +1,41 @@
+class SimulatorTimeline
+  class CardEvent < SimulatorTimeline::Event
+    attr_reader :player, :type, :reference
+
+    def initialize(event_handler, timeline, period_time, minute, options = {})
+      @player, @type, @reference = options.values_at :player, :type, :reference
+      @type ||= :yellow
+      super(event_handler, timeline, period_time, minute, options)
+    end
+
+    def to_foot_stats
+      {
+        "@Jogador" => @player.full_name,
+        "@Periodo" => SimulatorMatch::STATUS_MAP[SimulatorMatch::STATUSES[@period_time]],
+        "@Minuto"  => @minute.to_s,
+        "@Tipo"    => @type
+      }
+    end
+
+    def self.remove(timeline, reference)
+      timeline.home_cards.delete_if{ |event| event.reference == reference }
+      timeline.visitor_cards.delete_if{ |event| event.reference == reference }
+    end
+
+    def self.to_foot_stats(array_of_cards)
+      fuck_collection 'Cartoes', array_of_cards.map(&:to_foot_stats)
+    end
+
+    protected
+    def apply_event
+      if @player.simulator_team == @timeline.home_team
+        @timeline.home_cards << self
+      else
+        @timeline.visitor_cards << self
+      end
+
+      card_kind = (@type == :yellow) ? 'amarelo' : 'vermelho'
+      event_handler.narration :card, current_player: @player.nickname, card_kind: card_kind
+    end
+  end
+end

data/app/models/simulator_timeline/event.rb

@@ -0,0 +1,26 @@
+class SimulatorTimeline
+  class Event
+    attr_reader :period_time, :minute, :event_handler
+
+    def initialize(event_handler, timeline, period_time, minute, options = {})
+      @event_handler, @timeline, @period_time, @minute = event_handler, timeline, period_time, minute
+      apply_event
+    end
+
+    def <=>(other)
+      [@period_time, @minute] <=> [other.period_time, other.minute]
+    end
+
+    # Yeah... FootStats fucks collection...
+    def self.fuck_collection(key, collection)
+      case collection.size
+      when 0
+        nil
+      when 1
+        { key => collection.first }
+      else
+        { key => collection }
+      end
+    end
+  end
+end

data/app/models/simulator_timeline/event_handler.rb

@@ -0,0 +1,69 @@
+class SimulatorTimeline
+  class EventHandler
+    def initialize(timeline, period_time, minute)
+      @timeline, @period_time, @minute = timeline, period_time, minute
+    end
+
+    def add_goal(player, options={})
+      options = { player: player }.merge(options)
+      GoalEvent.new self, @timeline, @period_time, @minute, options
+    end
+
+    def remove_goal(reference)
+      GoalEvent.remove @timeline, reference
+    end
+
+    def add_card(player, options={})
+      options = { player: player }.merge(options)
+      CardEvent.new self, @timeline, @period_time, @minute, options
+    end
+
+    def add_yellow_card(player, options={})
+      options = { player: player, type: :yellow }.merge(options)
+      add_card player, options
+    end
+
+    def add_red_card(player, options={})
+      options = { player: player, type: :red }.merge(options)
+      add_card player, options
+    end
+
+    def remove_card(reference)
+      CardEvent.remove @timeline, reference
+    end
+
+    def escalation(players)
+      players.each do |player|
+        self.player(player)
+      end
+    end
+
+    def player(player, options={})
+      options = { player: player }.merge(options)
+      PlayerEvent.new self, @timeline, @period_time, @minute, options
+    end
+
+    def remove_player(reference)
+      PlayerEvent.remove @timeline, reference
+    end
+
+    def narration(message_name = :lorem, options = {})
+      message = if message_name.is_a?(String)
+        message_name
+      else
+        message = Lorem.new(@timeline, @period_time, @minute, options).public_send message_name
+      end
+      options = { message: message }.merge(options)
+      NarrationEvent.new self, @timeline, @period_time, @minute, options
+    end
+
+    def remove_narration(reference)
+      NarrationEvent.remove @timeline, reference
+    end
+
+    protected
+    def event(type, *args)
+      [@period_time, @minute, type, args]
+    end
+  end
+end

data/app/models/simulator_timeline/goal_event.rb

@@ -0,0 +1,40 @@
+class SimulatorTimeline
+  class GoalEvent < SimulatorTimeline::Event
+    attr_reader :player, :type, :reference
+
+    def initialize(event_handler, timeline, period_time, minute, options = {})
+      @player, @type, @reference = options.values_at :player, :type, :reference
+      @type ||= 'Favor'
+      super(event_handler, timeline, period_time, minute, options)
+    end
+
+    def to_foot_stats
+      {
+        "@Jogador" => @player.full_name,
+        "@Periodo" => SimulatorMatch::STATUS_MAP[SimulatorMatch::STATUSES[@period_time]],
+        "@Minuto"  => @minute.to_s,
+        "@Tipo"    => @type
+      }
+    end
+
+    def self.remove(timeline, reference)
+      timeline.home_goals.delete_if{ |event| event.reference == reference }
+      timeline.visitor_goals.delete_if{ |event| event.reference == reference }
+    end
+
+    def self.to_foot_stats(array_of_goals)
+      fuck_collection 'Gol', array_of_goals.map(&:to_foot_stats)
+    end
+
+    protected
+    def apply_event
+      if @player.simulator_team == @timeline.home_team
+        @timeline.home_goals << self
+      else
+        @timeline.visitor_goals << self
+      end
+
+      event_handler.narration :goal, current_player: @player.nickname, player_team: @player.simulator_team.full_name
+    end
+  end
+end

data/app/models/simulator_timeline/lorem.rb

@@ -0,0 +1,23 @@
+class SimulatorTimeline
+  class Lorem
+    attr_reader :timeline, :period_time, :minute
+    include LoremMessages
+
+    def initialize(timeline, period_time, minute, options = {})
+      @timeline, @period_time, @minute, @options = timeline, period_time, minute, options
+    end
+
+    def method_missing(method_name, *args, &block)
+      return render(@options[method_name])                         if @options[method_name]
+      return render(send("#{method_name}_message", *args, &block)) if respond_to?("#{method_name}_message")
+      return @timeline.public_send(method_name, *args, &block)     if @timeline.respond_to?(method_name)
+      super(method_name, *args, &block)
+    end
+
+    protected
+    def render(sentence)
+      normalized_sentence = sentence.is_a?(String) ? sentence : sample(sentence)
+      eval Erubis::Eruby.new(normalized_sentence).src, binding
+    end
+  end
+end