qwtf_discord_bot 5.1.8 → 5.3.0

data/lib/pug.rb

@@ -1,5 +1,6 @@
 class Pug
-  DEFAULT_MAXPLAYERS = 8
+  DEFAULT_TEAMSIZE = 4
+  MIN_NO_OF_TEAMS = 2
 
   def self.for(channel_id)
     new(channel_id)
@@ -9,21 +10,65 @@ class Pug
     @channel_id = channel_id
   end
 
-  def join(user_id)
+  def join(player_id)
     redis.setnx(pug_key, Time.now)
-    redis.sadd(players_key, user_id)
+
+    redis.sadd(team_key(0), player_id)
+  end
+
+  def join_team(team_no:, player_id:)
+    leave_teams(player_id)
+    redis.sadd(team_key(team_no), player_id)
   end
 
   def joined_players
-    redis.smembers(players_key).map(&:to_i)
+    teams_keys.inject([]) do |players, team|
+      players + redis.smembers(team).map(&:to_i)
+    end
+  end
+
+  def add_maps(maps)
+    redis.sadd(maps_key, maps)
+  end
+
+  def remove_maps(maps)
+    redis.srem(maps_key, maps)
+  end
+
+  def maps
+    redis.smembers(maps_key)
+  end
+
+  def vote(player_id:, map:)
+    redis.sadd(votes_key(map), player_id)
+  end
+
+  def vote_count(map)
+    redis.scard(votes_key(map)).to_i
+  end
+
+  def team(number)
+    redis.smembers(team_key(number)).map(&:to_i)
+  end
+
+  def teamsize=(teamsize)
+    redis.set(teamsize_key, teamsize)
   end
 
   def full?
     joined_player_count >= maxplayers
   end
 
+  def empty?
+    joined_player_count.zero?
+  end
+
   def joined_player_count
-    redis.scard(players_key).to_i
+    joined_players.count
+  end
+
+  def team_player_count(team_no)
+    redis.scard(team_key(team_no)).to_i
   end
 
   def player_slots
@@ -34,20 +79,24 @@ class Pug
     maxplayers - joined_player_count
   end
 
+  def game_map=(map)
+    redis.set([pug_key, 'map'].join(':'), map)
+  end
+
+  def game_map
+    redis.get([pug_key, 'map'].join(':'))
+  end
+
   def notify_roles=(roles)
     redis.set(notify_roles_key, roles)
   end
 
   def notify_roles
-    redis.get(notify_roles_key) || "@here"
-  end
-
-  def maxplayers=(maxplayers)
-    redis.set(maxplayers_key, maxplayers)
+    redis.get(notify_roles_key) || '@here'
   end
 
-  def maxplayers
-    (redis.get(maxplayers_key) || DEFAULT_MAXPLAYERS).to_i
+  def teamsize
+    (redis.get(teamsize_key) || DEFAULT_TEAMSIZE).to_i
   end
 
   def active?
@@ -55,42 +104,82 @@ class Pug
   end
 
   def leave(player_id)
-    redis.srem(players_key, player_id)
-    end_pug if empty?
+    leave_teams(player_id)
   end
 
   def end_pug
-    redis.del(pug_key)
-    redis.del(players_key)
+    redis.keys([pug_key, "*"].join).each do |key|
+      redis.del(key)
+    end
   end
 
   def joined?(player_id)
     joined_players.include?(player_id)
   end
 
+  def maxplayers
+    teamsize * no_of_teams
+  end
+
+  def teams
+    teams_keys.inject({}) do |teams, team|
+      teams.merge({ team.split(':').last => redis.smembers(team).map(&:to_i) })
+    end
+  end
+
+  def actual_teams
+    teams.tap { |team| team.delete("0") }
+  end
+
   private
 
-  def empty?
-    joined_player_count.zero?
+  def leave_teams(player_id)
+    teams_keys.each do |team|
+      redis.srem(team, player_id)
+    end
   end
 
-  def maxplayers_key
-    [pug_key, "maxplayers"].join(":")
+  def teams_keys
+    redis.keys([pug_key, 'teams:*'].join(':'))
   end
 
-  def players_key
-    [pug_key, "players"].join(":")
+  def team_key(team_no)
+    [pug_key, 'teams', team_no].join(':')
   end
 
   def pug_key
-    ["pug", "channel", @channel_id].join(":")
+    [channel_key, 'pug'].join(':')
+  end
+
+  def maps_key
+    [channel_key, 'maps'].join(':')
   end
 
   def notify_roles_key
-    [pug_key, "role"].join(":")
+    [channel_key, 'role'].join(':')
+  end
+
+  def teamsize_key
+    [channel_key, 'teamsize'].join(':')
+  end
+
+  def votes_keys
+    redis.keys([pug_key, 'votes:*'].join(':'))
+  end
+
+  def votes_key(map)
+    [channel_key, 'votes', map].join(':')
+  end
+
+  def channel_key
+    ['channel', @channel_id].join(':')
   end
 
   def redis
     Redis.current
   end
+
+  def no_of_teams
+    [actual_teams.count, MIN_NO_OF_TEAMS].max
+  end
 end

data/lib/qstat_request.rb

@@ -23,12 +23,14 @@ class QstatRequest
 
   def to_message
     return server_summary if is_empty?
+
     [server_summary, player_table].join("\n")
   end
 
   def server_summary
     return "#{@endpoint} isn't responding" unless game_map
     return "#{name} | #{@endpoint} | #{game_map} | #{numplayers}/#{maxplayers}" unless has_spectators?
+
     "#{name} | #{@endpoint} | #{game_map} | #{numplayers}/#{maxplayers} players | #{numspectators}/#{maxspectators} spectators"
   end
 
@@ -46,70 +48,70 @@ class QstatRequest
 
   private
 
-    def has_spectators?
-      numspectators && numspectators > 0
-    end
-
-    def teams
-      @teams ||= build_roster
-    end
+  def has_spectators?
+    numspectators && numspectators > 0
+  end
 
-    def data
-      @data ||= JSON.parse(result).first
-    end
+  def teams
+    @teams ||= build_roster
+  end
 
-    def execute
-      %x[qstat -json -P -qws #{@endpoint}]
-    end
+  def data
+    @data ||= JSON.parse(result).first
+  end
 
-    def player_table
-      players.sort_by { |player| player.team.number }.map(&:to_row).join("\n")
-    end
+  def execute
+    `qstat -json -P -qws #{@endpoint}`
+  end
 
-    def name
-      data["name"]
-    end
+  def player_table
+    players.sort_by { |player| player.team.number }.map(&:to_row).join("\n")
+  end
 
-    def address
-      data["address"]
-    end
+  def name
+    data['name']
+  end
 
-    def game_map
-      data["map"]
-    end
+  def address
+    data['address']
+  end
 
-    def numplayers
-      data["numplayers"]
-    end
+  def game_map
+    data['map']
+  end
 
-    def maxplayers
-      data["maxplayers"]
-    end
+  def numplayers
+    data['numplayers']
+  end
 
-    def numspectators
-      data["numspectators"]
-    end
+  def maxplayers
+    data['maxplayers']
+  end
 
-    def maxspectators
-      data["maxspectators"]
-    end
+  def numspectators
+    data['numspectators']
+  end
 
-    def build_roster
-      return nil if is_empty?
+  def maxspectators
+    data['maxspectators']
+  end
 
-      roster = Roster.new
+  def build_roster
+    return nil if is_empty?
 
-      data["players"].map do |player_data|
-        player = Player.new(player_data)
-        roster.enroll(player)
-      end
+    roster = Roster.new
 
-      roster.teams.sort_by { |team| team.number }
+    data['players'].map do |player_data|
+      player = Player.new(player_data)
+      roster.enroll(player)
     end
 
-    def players
-      data["players"].map do |player_data|
-        Player.new(player_data)
-      end
+    roster.teams.sort_by { |team| team.number }
+  end
+
+  def players
+    data['players'].map do |player_data|
+      Player.new(player_data)
     end
+  end
 end

data/lib/qwtf_discord_bot.rb

@@ -21,6 +21,7 @@ module QwtfDiscordBot # :nodoc:
   def self.config_file
     return ENV['QWTF_DISCORD_BOT_CONFIG_FILE'] if ENV['QWTF_DISCORD_BOT_CONFIG_FILE']
     return "#{Dir.pwd}/config.yaml" if FileTest.exist?("#{Dir.pwd}/config.yaml")
+
     "#{Dir.home}/.config/qwtf_discord_bot/config.yaml"
   end
 

data/lib/qwtf_discord_bot/config.rb

@@ -6,20 +6,20 @@ class Config
   end
 
   def token
-    @token ||= @config["token"]
+    @token ||= @config['token']
   end
 
   def client_id
-    @client_id ||= @config["client_id"]
+    @client_id ||= @config['client_id']
   end
 
   def endpoints
-    @endpoints ||= @config["endpoints"].map do |endpoint|
+    @endpoints ||= @config['endpoints'].map do |endpoint|
       Endpoint.new(endpoint)
     end
   end
 
   def emojis
-    @emojis ||= @config["emojis"]
+    @emojis ||= @config['emojis']
   end
 end

data/lib/qwtf_discord_bot/qwtf_discord_bot_pug.rb

@@ -6,6 +6,8 @@ require 'event_decorator'
 class QwtfDiscordBotPug # :nodoc:
   include QwtfDiscordBot
 
+  MSG_SNIPPET_DELIMITER = ' · '
+
   def run
     bot = Discordrb::Commands::CommandBot.new(
       token: QwtfDiscordBot.config.token,
@@ -16,134 +18,272 @@ class QwtfDiscordBotPug # :nodoc:
 
     bot.command :join do |event, *args|
       setup_pug(event) do |e, pug|
-        return message("You've already joined", e.channel) if pug.joined?(e.user_id)
-
-        pug.join(e.user_id)
-
-        message = if pug.joined_player_count == 1
-                    [
-                      "#{e.display_name} creates a PUG",
-                      pug.player_slots,
-                      pug.notify_roles
-                    ].join(' | ')
-                  elsif pug.slots_left.between?(1, 3)
-                    [
-                      "#{e.display_name} joins the PUG",
-                      pug.player_slots,
-                      "#{pug.slots_left} more",
-                      pug.notify_roles
-                    ].join(' | ')
-                  else
-                    [
-                      "#{e.display_name} joins the PUG",
-                      pug.player_slots
-                    ].join(' | ')
-                  end
-
-        message(message, e.channel)
-
-        if pug.full?
-          message = start_pug_message(
-            player_slots: pug.player_slots,
-            mentions: e.mentions_for(pug.joined_players)
-          )
+        return send_msg("You've already joined", e.channel) if pug.joined?(e.user_id)
 
-          message(message, e.channel)
-        end
+        join_pug(e, pug)
+        start_pug(pug, e) if pug.full?
       end
     end
 
     bot.command :status do |event, *args|
       setup_pug(event) do |e, pug|
-        message = if pug.active?
-                    [
-                      "#{e.display_names_for(pug.joined_players).join(', ')} joined",
-                      pug.player_slots
-                    ].join(' | ')
-                  else
-                    'No PUG has been started. `!join` to create'
-                  end
-
-        message(message, e.channel)
+        return send_msg('No PUG has been started. `!join` to create', e.channel) unless pug.active?
+
+        send_msg(
+          [
+            "#{pug.player_slots} joined",
+            "Map: #{pug.game_map}",
+            pug_teams_message(pug, e).join("\n")
+          ].join("\n"),
+          e.channel
+        )
       end
     end
 
-    bot.command :maxplayers do |event, *args|
+    bot.command :teamsize do |event, *args|
       setup_pug(event) do |e, pug|
-        new_maxplayers = args[0]
+        return send_msg("Team size is #{pug.teamsize}", e.channel) unless args.any?
 
-        message = if new_maxplayers
-                    pug.maxplayers = new_maxplayers
-                    "Max number of players set to #{pug.maxplayers} | #{pug.player_slots} joined"
-                  else
-                    "Current max number of players is #{pug.maxplayers} | #{pug.player_slots} joined"
-                  end
+        new_teamsize = args[0].to_i
+        return send_msg('Team size should be a number higher than 0', e.channel) unless new_teamsize > 0
 
-        message(message, e.channel)
+        if new_teamsize
+          pug.teamsize = new_teamsize
 
-        if pug.full?
-          message = start_pug_message(
-            player_slots: pug.player_slots,
-            mentions: e.mentions_for(pug.joined_players)
+          send_msg(
+            [
+              "Team size set to #{pug.teamsize}",
+              "#{pug.player_slots} joined"
+            ].join(MSG_SNIPPET_DELIMITER),
+            e.channel
           )
 
-          message(message, e.channel)
+          start_pug(pug, e) if pug.full?
+        else
+          send_msg(
+            [
+              "Current team size is #{pug.teamsize}",
+              "#{pug.player_slots} joined"
+            ].join(MSG_SNIPPET_DELIMITER),
+            e.channel
+          )
         end
       end
     end
 
     bot.command :leave do |event, *args|
       setup_pug(event) do |e, pug|
-        return message(no_active_pug_message, e.channel) unless pug.active?
-        return message("You're not in the PUG", e.channel) unless pug.joined?(e.user_id)
+        return send_msg(no_active_pug_message, e.channel) unless pug.active?
+        return send_msg("You're not in the PUG", e.channel) unless pug.joined?(e.user_id)
 
         pug.leave(e.user_id)
 
-        message(
-          "#{e.display_name} leaves the PUG | #{pug.player_slots} remain",
+        snippets = [
+          "#{e.display_name} leaves the PUG",
+          "#{pug.player_slots} remain"
+        ]
+
+        snippets << "#{pug.slots_left} more #{pug.notify_roles}" if pug.slots_left == 1
+
+        send_msg(
+          snippets.join(MSG_SNIPPET_DELIMITER),
           e.channel
         )
 
-        message(end_pug_message, e.channel) unless pug.active?
+        end_pug(pug, e.channel) if pug.empty?
       end
     end
 
     bot.command :kick do |event, *args|
       setup_pug(event) do |e, pug|
-        return message(no_active_pug_message, e.channel) unless pug.active?
+        return send_msg("Kick who? e.g. `!kick @#{e.display_name}`", e.channel) unless args.any?
+        return send_msg(no_active_pug_message, e.channel) unless pug.active?
 
-        args.each do |mention|
-          user_id = mention[3..-2].to_i
-          display_name = e.display_name_for(user_id)
+        args.each do |arg|
+          unless arg.match(/<@!\d+>/)
+            send_msg("#{arg} isn't a valid mention", e.channel)
+            next
+          end
 
-          unless pug.joined?(user_id)
-            message(
-              "#{display_name} isn't in the PUG",
-              e.channel
-            )
+          user_id = arg[3..-2].to_i
+          display_name = e.display_name_for(user_id) || arg
 
+          unless pug.joined?(user_id)
+            send_msg("#{display_name} isn't in the PUG", e.channel)
             next
           end
 
           pug.leave(user_id)
 
-          message(
-            "#{display_name} is kicked from the PUG | #{pug.player_slots} remain",
+          snippets = [
+            "#{display_name} is kicked from the PUG",
+            "#{pug.player_slots} remain"
+          ]
+
+          snippets << "#{pug.slots_left} more #{pug.notify_roles}" if pug.slots_left == 1
+
+          send_msg(
+            snippets.join(MSG_SNIPPET_DELIMITER),
             e.channel
           )
 
-          break message(end_pug_message, e.channel) unless pug.active?
+          break end_pug(pug, e.channel) if pug.empty?
+        end
+      end
+    end
+
+    bot.command :team do |event, *args|
+      setup_pug(event) do |e, pug|
+        team_no = args[0].to_i
+        return send_msg("Choose a team between 1 and 4", e.channel) unless team_no.between?(1, 4)
+
+        user_id = e.user_id
+        return send_msg("You're already in team #{team_no}", e.channel) if pug.team(team_no).include?(user_id)
+
+        join_pug(e, pug) unless pug.joined?(user_id)
+        pug.join_team(team_no: team_no, player_id: user_id)
+
+        send_msg(
+          [
+            "#{e.display_name} joins team #{team_no}",
+            "#{pug.team_player_count(team_no)}/#{pug.teamsize}"
+          ].join(MSG_SNIPPET_DELIMITER), e.channel
+        )
+
+        start_pug(pug, e) if pug.full?
+      end
+    end
+
+    bot.command :unteam do |event, *args|
+      setup_pug(event) do |e, pug|
+        user_id = e.user_id
+        return send_msg('No PUG has been started. `!join` to create', e.channel) unless pug.active?
+        return send_msg("You aren't in this PUG", e.channel) unless pug.joined?(user_id)
+        return send_msg("You aren't in a team", e.channel) if pug.team(0).include?(user_id)
+
+        pug.join_team(team_no: 0, player_id: user_id)
+        send_msg("#{e.display_name} has no team", e.channel)
+      end
+    end
+
+    bot.command :win do |event, *args|
+      setup_pug(event) do |e, pug|
+        return send_msg(no_active_pug_message, e.channel) unless pug.active?
+
+        winning_team_no = args[0]
+
+        return send_msg("Not a valid team", e.channel) unless pug.team(winning_team_no).any?
+
+        players = pug.joined_players.inject({}) do |memo, id|
+          memo.merge({ id => e.display_name_for(id) })
+        end
+
+        team_results = pug.teams.inject({}) do |teams, (name, player_ids)|
+          result = winning_team_no.to_i == name.to_i ? 1 : -1
+          teams.merge({ name => { players: players, result: result } })
+        end
+
+        post_results(
+          {
+            match: {
+              map: pug.game_map,
+              teams: team_results
+            }
+          }.to_json
+        )
+
+        # winning_team = pug.team(winning_team_no).map do |player_id|
+        #   e.display_name_for(player_id)
+        # end
+
+        # non_winning_teams = pug.actual_teams.tap { |team| team.delete(winning_team_no) }
+
+        # losing_players = non_winning_teams.values.flatten.map do |player_id|
+        #   e.display_name_for(player_id)
+        # end
+
+        send_msg("Team #{winning_team_no} wins", e.channel)
+      end
+    end
+
+    bot.command :draw do |event, *args|
+      setup_pug(event) do |e, pug|
+        return send_msg(no_active_pug_message, e.channel) unless pug.active?
+
+        players = pug.joined_players.inject({}) do |memo, id|
+          memo.merge({ id => e.display_name_for(id) })
         end
+
+        team_results = pug.teams.inject({}) do |teams, (name, player_ids)|
+          teams.merge({ name => { players: players, result: 0 } })
+        end
+
+        post_results(
+          {
+            match: {
+              map: pug.game_map,
+              teams: team_results
+            }
+          }.to_json
+        )
+
+        send_msg("Match drawn", e.channel)
       end
     end
 
     bot.command :end do |event, *args|
       setup_pug(event) do |e, pug|
-        return message(no_active_pug_message, e.channel) unless pug.active?
+        return send_msg(no_active_pug_message, e.channel) unless pug.active?
+
+        end_pug(pug, e.channel)
+      end
+    end
 
-        pug.end_pug
+    bot.command :addmap do |event, *args|
+      setup_pug(event) do |e, pug|
+        maps = args
+        return send_msg("What map? e.g. `!addmap 2fort5r`", e.channel) unless maps.any?
 
-        message(end_pug_message, e.channel)
+        pug.add_maps(maps)
+        send_msg("#{maps.join(', ')} added to maps", e.channel)
+      end
+    end
+
+    bot.command :removemap do |event, *args|
+      setup_pug(event) do |e, pug|
+        maps = args
+        return send_msg("What map? e.g. `!removemap 2fort5r`", e.channel) unless maps.any?
+
+        pug.remove_maps(maps)
+        send_msg("#{maps.join(', ')} removed from maps", e.channel)
+      end
+    end
+
+    bot.command :maps do |event, *args|
+      setup_pug(event) do |e, pug|
+        maps = pug.maps
+        return send_msg('No maps have been added. `!addmap`', e.channel) unless maps.any?
+
+        send_msg(maps.join(', '), e.channel)
+      end
+    end
+
+    bot.command :map do |event, *args|
+      setup_pug(event) do |e, pug|
+        maps = pug.maps
+        return send_msg('No maps have been added. `!addmap`', e.channel) unless maps.any?
+        return send_msg(no_active_pug_message, e.channel) unless pug.active?
+
+        if args.empty?
+          return send_msg('No map has been set for the current PUG', e.channel) unless pug.game_map
+          send_msg("Current map is #{pug.game_map}", e.channel)
+        else
+          game_map = args.first
+          return send_msg("#{game_map} isn't in the map list. `!addmap` to add it.", e.channel) unless maps.include?(game_map)
+
+          pug.game_map = game_map
+          send_msg("Map set to #{game_map}", e.channel)
+        end
       end
     end
 
@@ -152,13 +292,13 @@ class QwtfDiscordBotPug # :nodoc:
         roles = args.join(' ')
         pug.notify_roles = roles
 
-        message = if roles.empty?
-                    'Notification removed'
-                  else
-                    "Notification role set to #{roles}"
-                  end
+        msg = if roles.empty?
+                'Notification removed'
+              else
+                "Notification role set to #{roles}"
+              end
 
-        message(message, e.channel)
+        send_msg(msg, e.channel)
       end
     end
 
@@ -167,6 +307,19 @@ class QwtfDiscordBotPug # :nodoc:
 
   private
 
+  def join_pug(e, pug)
+    pug.join(e.user_id)
+
+    if pug.joined_player_count == 1
+      snippets = ["#{e.display_name} creates a PUG", pug.player_slots, pug.notify_roles]
+    else
+      snippets = ["#{e.display_name} joins the PUG", pug.player_slots]
+      snippets << "#{pug.slots_left} more #{pug.notify_roles}" if pug.slots_left.between?(1, 3)
+    end
+
+    send_msg(snippets.join(MSG_SNIPPET_DELIMITER), e.channel)
+  end
+
   def setup_pug(event)
     e = EventDecorator.new(event)
     pug = Pug.for(e.channel_id)
@@ -174,19 +327,71 @@ class QwtfDiscordBotPug # :nodoc:
     nil # stop discordrb printing return value
   end
 
-  def start_pug_message(player_slots:, mentions:)
-    ['Time to play!', player_slots, mentions.join(' ')].join(' | ')
+  def start_pug(pug, event)
+    pug_teams = pug.teams.map do |team_no, player_ids|
+      team_mentions = player_ids.map do |player_id|
+        event.mention_for(player_id)
+      end
+
+      team_status_line(
+        team_no: team_no.to_i,
+        names: team_mentions,
+        teamsize: pug.teamsize
+      )
+    end
+
+    msg = [
+      'Time to play!',
+      pug_teams
+    ].join("\n")
+
+    send_msg(msg, event.channel)
+  end
+
+  def pug_teams_message(pug, event)
+    pug.teams.map do |team_no, player_ids|
+      team_display_names = player_ids.map do |player_id|
+        event.display_name_for(player_id)
+      end
+
+      team_status_line(
+        team_no: team_no.to_i,
+        names: team_display_names,
+        teamsize: pug.teamsize
+      )
+    end
+  end
+
+  def team_status_line(team_no:, names:, teamsize:)
+    if team_no.to_i.zero?
+      ["No team: #{names.join(', ')}"]
+    else
+      [
+        "Team #{team_no}: #{names.join(', ')}",
+        "#{names.count}/#{teamsize}"
+      ].join(MSG_SNIPPET_DELIMITER)
+    end
   end
 
-  def end_pug_message
-    'PUG ended'
+  def end_pug(pug, channel_id)
+    pug.end_pug
+    send_msg('PUG ended', channel_id)
   end
 
   def no_active_pug_message
     "There's no active PUG"
   end
 
-  def message(message, channel)
+  def send_msg(message, channel)
     channel.send_message(message) && puts(message)
   end
+
+  def post_results(json)
+    uri = URI("#{ENV['RATINGS_API_URL']}matches/")
+    req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+    req.body = json
+    res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request(req)
+    end
+  end
 end