ssc.bot 0.1.1 → 0.2.0

data/lib/ssc.bot/user.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+#--
+# This file is part of SSC.Bot.
+# Copyright (c) 2020-2021 Jonathan Bradley Whited
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+
+require 'ssc.bot/user/message_sender'
+
+module SSCBot
+  ###
+  # @author Jonathan Bradley Whited
+  # @since  0.1.2
+  ###
+  module User
+  end
+end

data/lib/ssc.bot/user/jrobot_message_sender.rb

@@ -1,30 +1,18 @@
-#!/usr/bin/env ruby
 # encoding: UTF-8
 # frozen_string_literal: true
 
 #--
 # This file is part of SSC.Bot.
-# Copyright (c) 2020 Jonathan Bradley Whited (@esotericpig)
-# 
-# SSC.Bot is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-# 
-# SSC.Bot is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-# 
-# You should have received a copy of the GNU Lesser General Public License
-# along with SSC.Bot.  If not, see <https://www.gnu.org/licenses/>.
+# Copyright (c) 2020-2021 Jonathan Bradley Whited
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later
 #++
 
 
 begin
   require 'java'
 rescue LoadError => e
-  raise e.exception('Must use JRuby for JRobotMessageSender')
+  raise e.exception('Must use JRuby for SSCBot::User::JRobotMessageSender')
 end
 
 require 'attr_bool'
@@ -42,11 +30,10 @@ java_import 'java.awt.datatransfer.StringSelection'
 
 java_import 'java.awt.event.KeyEvent'
 
-
 module SSCBot
 module User
   ###
-  # @author Jonathan Bradley Whited (@esotericpig)
+  # @author Jonathan Bradley Whited
   # @since  0.1.0
   ###
   class JRobotMessageSender < MessageSender
@@ -60,21 +47,22 @@ module User
     attr_accessor? :warn_user
     attr_accessor :warn_user_key
     attr_accessor :warn_user_sleep
-    
-    def initialize(auto_delay: 110,msg_key: nil,os: Util::OS,warn_user: false,warn_user_key: KeyEvent::VK_BACK_SPACE,warn_user_sleep: 0.747,**kargs)
+
+    def initialize(auto_delay: 110,msg_key: nil,os: Util::OS,warn_user: false,
+                   warn_user_key: KeyEvent::VK_BACK_SPACE,warn_user_sleep: 0.747,**kargs)
       super(**kargs)
-      
-      @clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
+
+      @clipboard = Toolkit.getDefaultToolkit.getSystemClipboard
       @msg_key = msg_key
       @os = os
-      @robot = Robot.new()
+      @robot = Robot.new
       @warn_user = warn_user
       @warn_user_key = warn_user_key
       @warn_user_sleep = warn_user_sleep
-      
+
       @robot.setAutoDelay(auto_delay)
-      
-      @shortcut_paste = ->(ms) do
+
+      @shortcut_paste = lambda do |ms|
         if ms.os == :macos
           @shortcut_paste_macos.call(ms)
         else
@@ -84,87 +72,88 @@ module User
       @shortcut_paste_default = ->(ms) { ms.roll_keys(KeyEvent::VK_CONTROL,KeyEvent::VK_V) }
       @shortcut_paste_macos = ->(ms) { ms.roll_keys(KeyEvent::VK_META,KeyEvent::VK_V) }
     end
-    
-    def backspace()
+
+    def backspace
       return type_key(KeyEvent::VK_BACK_SPACE)
     end
-    
+
     def copy(str)
       @clipboard.setContents(StringSelection.new(str),nil)
-      
+
       return self
     end
-    
-    def enter()
+
+    def enter
       return type_key(KeyEvent::VK_ENTER)
     end
-    
+
     def paste(str=nil)
-      copy(str) unless str.nil?()
-      
+      copy(str) unless str.nil?
+
       @shortcut_paste.call(self)
-      
+
       return self
     end
-    
+
     def press_key(*key_codes)
-      key_codes.each() do |key_code|
+      key_codes.each do |key_code|
         @robot.keyPress(key_code)
       end
-      
+
       return self
     end
-    
+
     def put(message)
       # If do type_msg_key() and then warn_user(), then a backspace from
       #   warn_user() will cancel out the msg key.
       # Could do type_msg_key().warn_user().type_msg_key(), but then if the
       #   client is in windowed mode and msg key is a tab, then a backspace
       #   from warn_user() will do nothing.
-      return warn_user().
-             type_msg_key().
+      return warn_user.
+             type_msg_key.
              paste(message)
     end
-    
+
     def release_key(*key_codes)
-      key_codes.each() do |key_code|
+      key_codes.each do |key_code|
         @robot.keyRelease(key_code)
       end
-      
+
       return self
     end
-    
+
     def roll_keys(*key_codes)
-      key_codes.each() do |key_code|
+      key_codes.each do |key_code|
         @robot.keyPress(key_code)
       end
-      
+
       (key_codes.length - 1).downto(0) do |i|
         @robot.keyRelease(key_codes[i])
       end
-      
+
       return self
     end
-    
-    def send_message()
-      enter()
+
+    def send_message
+      enter
     end
-    
+
+    # TODO: implement type(message)
     def type(message)
       # TODO: implement type(message)
       super(message)
     end
-    
+
     def type_key(*key_codes)
-      key_codes.each() do |key_code|
+      key_codes.each do |key_code|
         @robot.keyPress(key_code)
         @robot.keyRelease(key_code)
       end
-      
+
       return self
     end
-    
-    def type_msg_key()
+
+    def type_msg_key
       if @msg_key
         if @msg_key.respond_to?(:call)
           @msg_key.call(self)
@@ -172,11 +161,11 @@ module User
           type_key(@msg_key)
         end
       end
-      
+
       return self
     end
-    
-    def warn_user()
+
+    def warn_user
       if @warn_user
         if @warn_user_key.respond_to?(:call)
           @warn_user_key.call(self)
@@ -186,7 +175,7 @@ module User
           release_key(@warn_user_key)
         end
       end
-      
+
       return self
     end
   end

data/lib/ssc.bot/user/message_sender.rb

@@ -1,23 +1,11 @@
-#!/usr/bin/env ruby
 # encoding: UTF-8
 # frozen_string_literal: true
 
 #--
 # This file is part of SSC.Bot.
-# Copyright (c) 2020 Jonathan Bradley Whited (@esotericpig)
-# 
-# SSC.Bot is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-# 
-# SSC.Bot is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-# 
-# You should have received a copy of the GNU Lesser General Public License
-# along with SSC.Bot.  If not, see <https://www.gnu.org/licenses/>.
+# Copyright (c) 2020-2021 Jonathan Bradley Whited
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later
 #++
 
 
@@ -27,19 +15,20 @@ require 'time'
 require 'ssc.bot/error'
 require 'ssc.bot/util'
 
-
 module SSCBot
 module User
   ###
-  # @author Jonathan Bradley Whited (@esotericpig)
+  # @author Jonathan Bradley Whited
   # @since  0.1.0
   ###
   class MessageSender
+    extend AttrBool::Ext
+
     DEFAULT_ESCAPE_STR = '.'
     DEFAULT_FLOOD_COUNT = 8
     DEFAULT_FLOOD_MIN_SLEEP = 0.001
     DEFAULT_FLOOD_SECS = 6
-    
+
     # Message Macros
     # - In order of F1 Help box.
     MM_TICKNAME = '%tickname'
@@ -57,7 +46,17 @@ module User
     MM_REDNAME = '%redname'
     MM_REDBOUNTY = '%redbounty'
     MM_REDFLAGS = '%redflags'
-    
+
+    constants.each do |constant|
+      name = constant.to_s
+
+      next unless name.start_with?('MM_')
+
+      define_method(name.downcase.to_sym) do
+        return self.class.const_get(constant)
+      end
+    end
+
     attr_accessor? :escape_percent
     attr_accessor? :escape_space
     attr_accessor :escape_str
@@ -67,22 +66,24 @@ module User
     attr_reader :message_count
     attr_reader :message_time
     attr_accessor? :staff
-    
+
     def put(message)
-      raise AbstractMethodError
+      raise AbstractMethodError,__method__
     end
-    
-    def send_message()
-      raise AbstractMethodError
+
+    def send_message
+      raise AbstractMethodError,__method__
     end
-    
+
     def type(message)
-      raise AbstractMethodError
+      raise AbstractMethodError,__method__
     end
-    
-    def initialize(escape_percent: false,escape_space: true,escape_str: DEFAULT_ESCAPE_STR,flood_count: DEFAULT_FLOOD_COUNT,flood_min_sleep: DEFAULT_FLOOD_MIN_SLEEP,flood_secs: DEFAULT_FLOOD_SECS,staff: false)
+
+    def initialize(escape_percent: false,escape_space: true,escape_str: DEFAULT_ESCAPE_STR,
+                   flood_count: DEFAULT_FLOOD_COUNT,flood_min_sleep: DEFAULT_FLOOD_MIN_SLEEP,
+                   flood_secs: DEFAULT_FLOOD_SECS,staff: false)
       super()
-      
+
       @escape_percent = escape_percent
       @escape_space = escape_space
       @escape_str = escape_str
@@ -90,17 +91,18 @@ module User
       @flood_min_sleep = flood_min_sleep
       @flood_secs = flood_secs
       @message_count = 0
-      @message_time = Time.now()
+      @message_time = Time.now
       @staff = staff
     end
-    
-    def escape_pub(message,escape_percent: @escape_percent,escape_space: @escape_space,escape_str: @escape_str,staff: @staff)
+
+    def escape_pub(message,escape_percent: @escape_percent,escape_space: @escape_space,
+                   escape_str: @escape_str,staff: @staff)
       if escape_percent
         message = message.gsub('%','%%')
       end
-      
+
       escape = false
-      
+
       case message[0]
       when '#'
         escape = true
@@ -109,13 +111,13 @@ module User
           escape = true
         else
           stripped_message = Util.u_lstrip(message)
-          
+
           case stripped_message[0]
           when ':'
             if stripped_message.index(':',1)
               escape = true
             end
-          when '/',%q{'},'"',';','='
+          when '/',"'",'"',';','='
             escape = true
           when '?'
             if stripped_message[1] =~ /[[:alpha:]]/
@@ -126,253 +128,193 @@ module User
           end
         end
       end
-      
+
       if escape
         message = "#{escape_str}#{message}"
       end
-      
+
       return message
     end
-    
-    def prevent_flood()
+
+    def prevent_flood
       @message_count += 1
-      
+
       if @message_count >= @flood_count
-        diff_time = Time.now() - @message_time
-        
+        diff_time = Time.now - @message_time
+
         if diff_time <= @flood_secs
           sleep_secs = (@flood_secs - diff_time).round(4) + 0.001
           sleep_secs = @flood_min_sleep if sleep_secs < @flood_min_sleep
         else
           sleep_secs = @flood_min_sleep
         end
-        
+
         sleep(sleep_secs)
-        
+
         @message_count = 0
       end
-      
-      @message_time = Time.now()
+
+      @message_time = Time.now
     end
-    
+
     def put_or_type(message)
       put(message)
     end
-    
+
     def send(message)
       put(message)
-      send_message()
+      send_message
     end
-    
+
     def send_or_types(message)
       send(message)
     end
-    
+
     def send_or_types_safe(message)
       send_or_types(message)
-      prevent_flood()
+      prevent_flood
     end
-    
+
     def send_safe(message)
       send(message)
-      prevent_flood()
+      prevent_flood
     end
-    
+
     def types(message)
       type(message)
-      send_message()
+      send_message
     end
-    
+
     def types_safe(message)
       types(message)
-      prevent_flood()
+      prevent_flood
     end
-    
+
     def send_chat(message)
       send_safe(";#{message}")
     end
-    
+
     def send_chat_to(channel,message)
       send_safe(";#{channel};#{message}")
     end
-    
+
     def send_freq(message)
-      send_safe(%Q{"#{message}})
+      send_safe(%Q("#{message}))
     end
-    
+
     def send_freq_eq(freq)
       send_safe("=#{freq}")
     end
-    
+
     def send_private(message)
       send_safe("/#{message}")
     end
-    
+
     def send_private_to(name,message)
       send_safe(":#{name}:#{message}")
     end
-    
+
     def send_private_to_last(message,last=1)
       put_or_type('::')
-      
+
       while (last -= 1) > 0
         put_or_type(':')
       end
-      
+
       send_safe(message)
     end
-    
+
     def send_pub(message,**kargs)
       send_safe(escape_pub(message,**kargs))
     end
-    
-    def send_q_chat()
+
+    def send_q_chat
       send_safe('?chat')
     end
-    
+
     def send_q_chat_eq(*names)
       send_safe("?chat=#{names.join(',')}")
     end
-    
-    def send_q_enter()
+
+    def send_q_enter
       send_safe('?enter')
     end
-    
+
     def send_q_find(player)
       send_safe("?find #{player}")
     end
-    
-    def send_q_kill()
+
+    def send_q_kill
       send_safe('?kill')
     end
-    
-    def send_q_leave()
+
+    def send_q_leave
       send_safe('?leave')
     end
-    
+
     def send_q_loadmacro(filename)
       send_safe("?loadmacro #{filename}")
     end
-    
-    def send_q_log()
+
+    def send_q_log
       send_safe('?log')
     end
-    
+
     def send_q_log_to(filename)
       send_safe("?log #{filename}")
     end
-    
-    def send_q_logbuffer()
+
+    def send_q_logbuffer
       send_safe('?logbuffer')
     end
-    
+
     def send_q_logbuffer_to(filename)
       send_safe("?logbuffer #{filename}")
     end
-    
-    def send_q_namelen()
+
+    def send_q_namelen
       send_safe('?namelen')
     end
-    
+
     def send_q_namelen_eq(namelen)
       send_safe("?namelen=#{namelen}")
     end
-    
-    def send_q_lines()
+
+    def send_q_lines
       send_safe('?lines')
     end
-    
+
     def send_q_lines_eq(lines)
       send_safe("?lines=#{lines}")
     end
-    
+
     def send_q_savemacro(filename)
       send_safe("?savemacro #{filename}")
     end
-    
-    def send_q_spec()
+
+    def send_q_spec
       send_safe('?spec')
     end
-    
-    def send_q_team()
+
+    def send_q_team
       send_safe('?team')
     end
-    
+
     def send_squad(message)
       send_safe("##{message}")
     end
-    
+
     def send_squad_to(squad,message)
       send_safe(":##{squad}:#{message}")
     end
-    
+
     def send_team(message)
       send_safe("//#{message}")
     end
-    
+
     def send_team2(message)
       send_safe("'#{message}")
     end
-    
-    def mm_tickname()
-      return MM_TICKNAME
-    end
-    
-    def mm_selfname()
-      return MM_SELFNAME
-    end
-    
-    def mm_squad()
-      return MM_SQUAD
-    end
-    
-    def mm_freq()
-      return MM_FREQ
-    end
-    
-    def mm_bounty()
-      return MM_BOUNTY
-    end
-    
-    def mm_flags()
-      return MM_FLAGS
-    end
-    
-    def mm_energy()
-      return MM_ENERGY
-    end
-    
-    def mm_killer()
-      return MM_KILLER
-    end
-    
-    def mm_killed()
-      return MM_KILLED
-    end
-    
-    def mm_coord()
-      return MM_COORD
-    end
-    
-    def mm_area()
-      return MM_AREA
-    end
-    
-    def mm_red()
-      return MM_RED
-    end
-    
-    def mm_redname()
-      return MM_REDNAME
-    end
-    
-    def mm_redbounty()
-      return MM_REDBOUNTY
-    end
-    
-    def mm_redflags()
-      return MM_REDFLAGS
-    end
   end
 end
 end