kag-gather 1.3.4 → 1.3.5

data/lib/kag/match.rb

@@ -1,158 +0,0 @@
-require 'cinch'
-require 'symboltable'
-require 'kag/config'
-require 'kag/team'
-
-module KAG
-  class Match < SymbolTable
-
-    def self.type_as_string
-      ms = KAG::Config.instance[:match_size].to_i
-      ts = (ms / 2).ceil
-      "#{ts.to_s}v#{ts.to_s} #{KAG::Config.instance[:match_type]}"
-    end
-
-    def setup_teams
-      self[:players].shuffle!
-      match_size = KAG::Config.instance[:match_size].to_i
-      match_size = 2 if match_size < 2
-
-      lb = (match_size / 2).ceil.to_i
-      lb = 1 if lb < 1
-
-      debug "MATCH SIZE #{match_size.to_s}"
-      debug "LOWER BOUND: #{lb.to_s}"
-      debug "PLAYERS: #{self[:players].join(",")}"
-
-      self[:teams] = []
-      self[:teams] << KAG::Team.new({
-        :players => self[:players].slice(0,lb),
-        :match => self,
-        :color => "\x0312",
-        :name => "Blue"
-      }).setup
-      self[:teams] << KAG::Team.new({
-        :players => self[:players].slice(lb,match_size),
-        :match => self,
-        :color => "\x0304",
-        :name => "Red"
-      }).setup
-      self[:teams]
-    end
-
-    def start
-      self[:end_votes] = 0 unless self[:end_votes]
-      self[:subs_needed] = []
-      setup_teams
-      restart_map
-    end
-
-    def text_for_match_start
-      msg = "MATCH: #{KAG::Match.type_as_string} - "
-      self[:teams].each do |team|
-        msg = msg+" "+team.text_for_match_start
-      end
-      msg+" \x0301(!end when done)"
-    end
-
-    def notify_teams_of_match_start
-      messages = {}
-      self[:teams].each do |t|
-        ms = t.notify_of_match_start
-        ms.each do |nick,msg|
-          messages[nick] = msg
-        end
-      end
-      messages
-    end
-
-    def add_end_vote
-      self[:end_votes] = 0 unless self[:end_votes] > 0
-      self[:end_votes] = self[:end_votes] + 1
-    end
-
-    def voted_to_end?
-      evt = KAG::Config.instance[:end_vote_threshold].to_i
-      evt = 3 if evt < 1
-      self[:end_votes] >= evt
-    end
-
-    def get_needed_end_votes_left
-      evt = KAG::Config.instance[:end_vote_threshold].to_i
-      evt - self[:end_votes]
-    end
-
-    def has_player?(nick)
-      playing = false
-      self[:teams].each do |team|
-        playing = true if team.has_player?(nick)
-      end
-      playing
-    end
-
-    def cease
-      if self.server
-        if self.server.has_rcon?
-          self[:teams].each do |team|
-            team.kick_all
-          end
-        else
-          debug "NO RCON, so could not kick!"
-        end
-        self.server.disconnect
-        self.server.delete(:match)
-        true
-      else
-        debug "No server for match defined!"
-        false
-      end
-    end
-
-    def restart_map
-      if self.server.has_rcon?
-        self.server.restart_map
-      else
-        debug "Cannot restart map, no RCON defined"
-      end
-    end
-
-    def remove_player(nick)
-      sub = false
-      self[:teams].each do |team|
-        if team.has_player?(nick)
-          sub = team.remove_player(nick)
-        end
-      end
-      if sub
-        self[:subs_needed] << sub
-      end
-      sub
-    end
-
-    def needs_sub?
-      self[:subs_needed].length > 0
-    end
-
-    def sub_in(nick)
-      placement = false
-      if needs_sub?
-        placement = self[:subs_needed].shift
-      end
-      placement
-    end
-
-    def rename_player(last_nick,new_nick)
-      self[:teams].each do |team|
-        if team.has_player?(last_nick)
-          team.rename_player(last_nick,new_nick)
-        end
-      end
-    end
-
-    def debug(msg)
-      if KAG::Config.instance[:debug]
-        puts msg
-      end
-    end
-  end
-end

data/lib/kag/report.rb

@@ -1,146 +0,0 @@
-require 'symboltable'
-require 'kag/data'
-require 'kag/config'
-
-module KAG
-  class Report < SymbolTable
-
-    def initialize(gather,m,user)
-      hash = {
-        :nick => user.nick,
-        :authname => user.authname,
-        :host => user.host,
-        :realname => user.realname,
-        :gather => gather,
-        :message => m,
-        :count => 1
-      }
-      super(hash)
-      _ensure_data
-      if reported?
-        if can_report?
-          if past_threshold?
-            ignore
-          else
-            up_report_count
-          end
-        else
-          self.gather.reply self.message,"You have already reported #{self[:nick]}. You can only report a user once."
-        end
-      else
-        report
-      end
-    end
-
-    def can_report?
-      r = _report
-      if r and r[:reporters]
-        !r[:reporters].include?(self.message.user.authname)
-      else
-        true
-      end
-    end
-
-    def _ensure_data
-      data[:reported] = {} unless data[:reported]
-      data[:ignored] = {} unless data[:ignored]
-    end
-
-    def reported?
-      data[:reported].key?(self[:host].to_sym)
-    end
-
-    def report
-      puts self.message.inspect
-      c = self.dup
-      c.delete(:gather)
-      c.delete(:message)
-      c[:reporters] = [self.message.user.authname]
-      data[:reported][self[:host].to_sym] = c
-      data.save
-
-      self.gather.reply self.message,"User #{self[:nick]} reported." if self.gather.class == KAG::Gather
-    end
-
-    def ignore
-      c = self.clone
-      c.delete(:gather)
-      c.delete(:message)
-      data[:ignored][self[:host].to_sym] = c
-      data.save
-      self.gather.reply self.message,"User #{self[:nick]} ignored." if self.gather.class == KAG::Gather
-    end
-
-    def past_threshold?
-      _report[:count].to_i > KAG::Config.instance[:report_threshold].to_i
-    end
-
-    def up_report_count
-      _report[:count] = _report[:count].to_i + 1
-      _report[:reporters] = [] unless _report[:reporters]
-      _report[:reporters] << self.message.user.authname
-      data.save
-
-      self.gather.reply message,"User #{self[:nick]} reported. #{self[:nick]} has now been reported #{data[:reported][self[:host].to_sym][:count]} times." if self.gather.class == KAG::Gather
-    end
-
-    def self.ignore(gather,message,user)
-      KAG::Config.data[:ignored] = {} unless KAG::Config.data[:ignored]
-      if KAG::Config.data[:ignored] and !KAG::Config.data[:ignored].key?(user.host.to_sym)
-        c = SymbolTable.new({
-          :nick => user.nick,
-          :authname => user.authname,
-          :host => user.host,
-          :realname => user.realname,
-          :gather => gather,
-          :message => message,
-          :reporters => [message.user.authname]
-        })
-        KAG::Config.data[:ignored][user.host.to_sym] = c
-        KAG::Config.data.save
-
-        gather.reply message,"User #{user.nick} added to ignore list." if gather.class == KAG::Gather
-        true
-      else
-        gather.reply message,"User #{user.nick} already in ignore list!" if gather.class == KAG::Gather
-        false
-      end
-    end
-
-    def self.remove(gather,message,user)
-      if KAG::Config.data[:reported] and KAG::Config.data[:reported].key?(user.host.to_sym)
-        KAG::Config.data[:reported].delete(user.host.to_sym)
-        KAG::Config.data.save
-
-        gather.reply message,"User #{user.nick} removed from report list." if gather.class == KAG::Gather
-        true
-      else
-        gather.reply message,"User #{user.nick} not in report list!" if gather.class == KAG::Gather
-        false
-      end
-    end
-
-    def self.unignore(gather,message,user)
-      if KAG::Config.data[:ignored] and KAG::Config.data[:ignored].key?(user.host.to_sym)
-        KAG::Config.data[:ignored].delete(user.host.to_sym)
-        KAG::Config.data.save
-
-        gather.reply message,"User #{user.nick} removed from ignore list." if gather.class == KAG::Gather
-        true
-      else
-        gather.reply message,"User #{user.nick} not in ignore list!" if gather.class == KAG::Gather
-        false
-      end
-    end
-
-    protected
-
-    def data
-      KAG::Config.data
-    end
-
-    def _report
-      data[:reported][self[:host].to_sym]
-    end
-  end
-end

data/lib/kag/team.rb

@@ -1,82 +0,0 @@
-require 'cinch'
-require 'cinch/user'
-require 'symboltable'
-require 'kag/config'
-
-module KAG
-  class Team < SymbolTable
-
-    def setup
-      setup_classes
-      self
-    end
-
-    def setup_classes
-      classes = KAG::Config.instance[:classes].clone
-      classes.shuffle!
-      players = self[:players].clone
-      self[:players] = {}
-      players.each do |p|
-        self[:players][p.to_sym] = classes.shift
-      end
-      self
-    end
-
-    def notify_of_match_start
-      server = self.match.server
-      msg = "Join \x0305#{server[:key]} - #{server[:ip]}:#{server[:port]} \x0306password #{server[:password]}\x0301 | Visit kag://#{server[:ip]}/#{server[:password]} | "
-      msg = msg + " \x0303Class: " if KAG::Config.instance[:pick_classes]
-
-      messages = {}
-      self[:players].each do |nick,cls|
-        player_msg = msg.clone
-        player_msg = player_msg+cls if KAG::Config.instance[:pick_classes] and cls and !cls.empty?
-        player_msg = player_msg+" #{self[:color]}#{self[:name]} with: #{self[:players].keys.join(", ")}"
-        messages[nick] = player_msg
-      end
-      messages
-    end
-
-    def text_for_match_start
-      "#{self[:color]}#{self[:players].keys.join(", ")} (#{self[:name]})"
-    end
-
-    def has_player?(nick)
-      self[:players].keys.include?(nick.to_sym)
-    end
-
-    def rename_player(last_nick,new_nick)
-      if has_player?(nick)
-        cls = self[:players][last_nick.to_sym]
-        self[:players].delete(last_nick.to_sym)
-        self[:players][new_nick.to_sym] = cls
-      end
-    end
-
-    def remove_player(nick)
-      if has_player?(nick)
-        sub = {}
-        sub[:cls] = self[:players][nick]
-        sub[:team] = self.clone
-        sub[:msg] = "Sub needed at #{self.match.server[:ip]} for #{sub[:team][:name]}, #{sub[:cls]} Class! Type !sub to claim it!"
-        sub[:channel_msg] = "#{nick} is now subbing in for #{self[:name]} at #{self.match.server[:key]}. Subs still needed: #{self.match[:subs_needed].length}"
-        sub[:private_msg] = "Please #{self.match.server.text_join} | #{sub[:cls]} on the #{self[:name]} Team"
-        self[:players].delete(nick)
-
-        if self.match and self.match.server
-          self.match.server.kick(nick)
-        end
-
-        sub
-      else
-        false
-      end
-    end
-
-    def kick_all
-      self[:players].each do |nick,cls|
-        self.match.server.kick(nick.to_s)
-      end
-    end
-  end
-end