procon_bypass_man 0.1.20.2 → 0.1.23

data/lib/procon_bypass_man/procon/analog_stick_manipulator.rb

@@ -0,0 +1,36 @@
+class ProconBypassMan::Procon::AnalogStickManipulator
+  attr_accessor :manipulated_abs_x, :manipulated_abs_y
+
+  def initialize(binary, method: )
+    analog_stick = ProconBypassMan::Procon::AnalogStick.new(binary: binary)
+
+    if method =~ /tilt_left_stick_(completely)_to_(left|right)/
+      power_level = $1
+      direction = $2
+
+      case direction
+      when 'left'
+        self.manipulated_abs_x = 400
+        # yを引き継ぐとタンサンボムの溜まりが悪くなったので固定値を入れる
+        self.manipulated_abs_y = analog_stick.abs_y
+        # self.manipulated_abs_y = 1808
+      when 'right'
+        self.manipulated_abs_x = 3400
+        self.manipulated_abs_y = 1808
+      end
+    else
+      warn "error stick manipulator"
+      self.manipulated_abs_x = analog_stick.abs_x
+      self.manipulated_abs_y = analog_stick.abs_y
+    end
+  end
+
+
+  # @return [String]
+  def to_binary
+    ProconBypassMan::AnalogStickPosition.new(
+      x: self.manipulated_abs_x,
+      y: self.manipulated_abs_y,
+    ).to_binary
+  end
+end

data/lib/procon_bypass_man/procon/button_collection.rb

@@ -37,12 +37,4 @@ class ProconBypassMan::Procon::ButtonCollection
   BUTTONS = ProconBypassMan::Procon::ButtonCollection::BUTTONS_MAP.keys.freeze
 
   LEFT_ANALOG_STICK = { byte_position: 6..8 }
-
-  # @param [Array<Symbol>] buttons
-  # @return [Array<Symbol>]
-  def self.normalize(buttons)
-    buttons.select { |x|
-      !!ProconBypassMan::Procon::ButtonCollection::BUTTONS_MAP[x]
-    }
-  end
 end

data/lib/procon_bypass_man/procon/layer_changer.rb

@@ -24,7 +24,10 @@ class ProconBypassMan::Procon::LayerChanger
   # @return [Boolean]
   def change_layer?
     if ProconBypassMan::ButtonsSettingConfiguration.instance.prefix_keys.empty?
-      raise "prefix_keysが未設定です"
+      ProconBypassMan.cache.fetch key: 'unknown prefix_keys', expires_in: 60 do
+        warn "prefix_keysが未設定です"
+      end
+      return false
     end
     ProconBypassMan::ButtonsSettingConfiguration.instance.prefix_keys.map { |b| pressed?(button: b) }.all?
   end

data/lib/procon_bypass_man/procon/macro.rb

@@ -1,13 +1,51 @@
 class ProconBypassMan::Procon::Macro
-  class NestedStep
+  class BaseNestedStep
     def initialize(value)
       @hash = value
+    end
+
+    private
+
+    def incr_step_index!
+      if step_index
+        @hash[:step_index] += 1
+      else
+        @hash[:step_index] = 0
+      end
+    end
+
+    def current_step
+      @hash[:steps][step_index]
+    end
+  end
+
+  class OnetimeNestedStep < BaseNestedStep
+    def over?
+      current_step.nil?
+    end
+
+    def next_step
+      step = current_step
+      incr_step_index!
+      step
+    end
+
+    private
+
+    def step_index
+      @hash[:step_index] ||= 0
+    end
+  end
+
+  class NestedStep < BaseNestedStep
+    def initialize(value)
+      super
       unless @hash[:end_at]
         @hash[:end_at] = (Time.now + @hash[:continue_for]).round(4)
       end
     end
 
-    def over_end_at?
+    def over?
       (@hash[:end_at] < Time.now).tap do |result|
         if result
           ProconBypassMan.logger.debug { "[Macro] nested step is finished(#{@hash})" }
@@ -17,8 +55,6 @@ class ProconBypassMan::Procon::Macro
 
     def next_step
       incr_step_index!
-
-      debug_incr_called_count!
       if step = current_step
         return step
       else
@@ -29,37 +65,22 @@ class ProconBypassMan::Procon::Macro
 
     private
 
-    def current_step
-      @hash[:steps][step_index]
-    end
-
     def step_index
       @hash[:step_index]
     end
 
-    def incr_step_index!
-      if step_index
-        @hash[:step_index] += 1
-      else
-        @hash[:step_index] = 0
-      end
-    end
-
     def reset_step_index!
       @hash[:step_index] = 0
     end
-
-    def debug_incr_called_count!
-      @hash[:debug_called_count] ||= 0
-      @hash[:debug_called_count] += 1
-    end
   end
 
-  attr_accessor :name, :steps
+  attr_accessor :name, :steps, :after_callback_block, :force_neutral_buttons
 
-  def initialize(name: , steps: )
+  def initialize(name: , steps: , force_neutral_buttons: [], &after_callback_block)
     self.name = name
     self.steps = steps
+    self.after_callback_block = after_callback_block
+    self.force_neutral_buttons = force_neutral_buttons # 外部から呼ばれるだけ
   end
 
   def next_step
@@ -69,9 +90,16 @@ class ProconBypassMan::Procon::Macro
     end
 
     if step.is_a?(Hash)
-      nested_step = NestedStep.new(step)
-      if nested_step.over_end_at?
+      nested_step =
+        if step[:continue_for]
+          NestedStep.new(step)
+        else
+          OnetimeNestedStep.new(step)
+        end
+
+      if nested_step.over?
         steps.shift # NestedStepを破棄する
+        self.after_callback_block.call if self.after_callback_block
         return next_step
       else
         return nested_step.next_step

data/lib/procon_bypass_man/procon/macro_builder.rb

@@ -13,34 +13,32 @@ class ProconBypassMan::Procon::MacroBuilder
 
   class Subject
     def initialize(value)
-      @button =
-        if match = value.match(/_(\w+)\z/)
-          match[1]
-        else
-          :unknown
-        end
+      if not /^shake_/ =~ value
+        @button =
+          if match = value.match(/_(\w+)\z/)
+            match[1]
+          else
+            :unknown
+          end
+      end
       @type =
         if value.start_with?("toggle_")
           :toggle
+        elsif value.start_with?("shake_left_stick")
+          :shake_left_stick
         else
           :pressing
         end
     end
 
-    def toggle?
-      @type == :toggle
-    end
-
-    def pressing?
-      not toggle?
-    end
-
     def to_steps
       case @type
       when :toggle
         [@button.to_sym, :none]
       when :pressing
         [@button.to_sym, @button.to_sym]
+      when :shake_left_stick
+        [:tilt_left_stick_completely_to_left, :tilt_left_stick_completely_to_right]
       end
     end
   end
@@ -56,7 +54,7 @@ class ProconBypassMan::Procon::MacroBuilder
 
   # @return [Arary<Symbol>]
   def build
-    steps = @steps.map { |step|
+    steps = @steps.flat_map { |step|
       if is_reserved?(step: step) || v1_format?(step: step)
         step.to_sym
       elsif value = build_if_v2_format?(step: step)
@@ -65,7 +63,8 @@ class ProconBypassMan::Procon::MacroBuilder
         nil
       end
     }
-    steps.compact.flatten
+
+    steps.compact
   end
 
   private
@@ -81,31 +80,40 @@ class ProconBypassMan::Procon::MacroBuilder
   end
 
   def build_if_v2_format?(step: )
-    # 時間指定なし
-    if(match = step.match(%r!\Atoggle_(\w+)\z!)) && (button_candidate = match[1]) && is_button(button_candidate)
-      button = button_candidate
-      return [button.to_sym, :none]
-    end
-
-    # 時間指定あり
-    if %r!^(pressing_|toggle_)! =~ step && (subjects = step.scan(%r!pressing_[^_]+|toggle_[^_]+!)) && (match = step.match(%r!_for_([\d_]+)(sec)?\z!))
-      sec = match[1]
-      return [
-        { continue_for: to_num(sec),
-          steps: SubjectMerger.merge(subjects.map { |x| Subject.new(x) }),
-        }
-      ]
-    end
-
     # no-op command
     if(match = step.match(%r!wait_for_([\d_]+)(sec)?\z!))
       sec = match[1]
       return [
-        { continue_for: to_num(sec),
+        { continue_for: to_f(sec),
           steps: [:none],
         }
       ]
     end
+
+    if %r!^(pressing_|toggle_|shake_left_stick_)! =~ step && (subjects = step.scan(%r!pressing_[^_]+|shake_left_stick|toggle_[^_]+!)) && (match = step.match(%r!_for_([\d_]+)(sec)?\z!))
+      if sec = match[1]
+        return {
+          continue_for: to_f(sec),
+          steps: SubjectMerger.merge(subjects.map { |x| Subject.new(x) }).select { |x|
+            if x.is_a?(Array)
+              x.select { |y| is_button(y) || RESERVED_WORD_NONE == y }
+            else
+              is_button(x) || RESERVED_WORD_NONE == x || :tilt_left_stick_completely_to_left == x || :tilt_left_stick_completely_to_right == x
+            end
+          },
+        }
+      end
+    end
+
+    if %r!^(pressing_|toggle_|shake_left_stick_)! =~ step && (subjects = step.scan(%r!pressing_[^_]+|shake_left_stick|toggle_[^_]+!))
+      return SubjectMerger.merge(subjects.map { |x| Subject.new(x) }).select { |x|
+        if x.is_a?(Array)
+          x.select { |y| is_button(y) || RESERVED_WORD_NONE == y }
+        else
+          is_button(x) || RESERVED_WORD_NONE == x
+        end
+      }
+    end
   end
 
   # @return [Boolean]
@@ -113,11 +121,11 @@ class ProconBypassMan::Procon::MacroBuilder
     !!ProconBypassMan::Procon::ButtonCollection::BUTTONS_MAP[step.to_sym]
   end
 
-  def to_num(value)
+  def to_f(value)
     if value.include?("_")
       value.sub("_", ".").to_f
     else
-      value.to_i
+      value.to_f
     end
   end
 end

data/lib/procon_bypass_man/procon/macro_plugin_map.rb

@@ -0,0 +1,23 @@
+module ProconBypassMan
+  class Procon
+    # macroキーにメタデータを埋め込んでいる. 通常の処理ではメタデータを露出したくないので露出しないためのクラス
+    class MacroPluginMap < ::Hash
+      def [](value)
+        self.fetch([value, :normal], nil)
+      end
+
+      def each
+        transform_keys(&:first).each { |x| yield(x[0], x[1]) }
+      end
+
+      alias_method :original_keys, :keys
+      def keys
+        super.map(&:first)
+      end
+
+      def raw_keys
+        self.original_keys
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/procon/macro_registry.rb

@@ -3,28 +3,44 @@ class ProconBypassMan::Procon::MacroRegistry
     null: [],
   }
 
-  def self.install_plugin(klass, steps: nil)
-    if plugins[klass.to_s.to_sym]
-      raise "#{klass} macro is already registered"
+  def self.install_plugin(klass, steps: nil, macro_type: :normal)
+    if plugins.fetch([klass.to_s.to_sym, macro_type], nil)
+      Kernel.warn "#{klass} macro is already registered"
+      return
     end
 
-    plugins[klass.to_s.to_sym] = ->{
-      ProconBypassMan::Procon::MacroBuilder.new(steps || klass.steps).build
-    }
+    plugins.store(
+      [klass.to_s.to_sym, macro_type], ->{
+        ProconBypassMan::Procon::MacroBuilder.new(steps || klass.steps).build
+      }
+    )
   end
 
-  def self.load(name)
-    steps = PRESETS[name] || plugins[name].call || raise("unknown macro")
-    ProconBypassMan::Procon::Macro.new(name: name, steps: steps.dup)
+  # @return [ProconBypassMan::Procon::Macro]
+  def self.load(name, macro_type: :normal, force_neutral_buttons: [], &after_callback_block)
+    if(steps = PRESETS[name] || plugins.fetch([name.to_s.to_sym, macro_type], nil)&.call)
+      return ProconBypassMan::Procon::Macro.new(name: name, steps: steps.dup, force_neutral_buttons: force_neutral_buttons, &after_callback_block)
+    else
+      warn "installされていないマクロ(#{name})を使うことはできません"
+      return self.load(:null)
+    end
   end
 
   def self.reset!
-    ProconBypassMan::ButtonsSettingConfiguration.instance.macro_plugins = {}
+    ProconBypassMan::ButtonsSettingConfiguration.instance.macro_plugins = ProconBypassMan::Procon::MacroPluginMap.new
   end
 
   def self.plugins
     ProconBypassMan::ButtonsSettingConfiguration.instance.macro_plugins
   end
 
+  def self.cleanup_remote_macros!
+    remote_keys = ProconBypassMan::Procon::MacroRegistry.plugins.original_keys.select { |_, y| y == :remote }
+    remote_keys.each do |remote_key|
+      ProconBypassMan::Procon::MacroRegistry.plugins.delete(remote_key)
+    end
+    ProconBypassMan::Procon::MacroRegistry.plugins
+  end
+
   reset!
 end

data/lib/procon_bypass_man/procon/suppress_rumble.rb

@@ -0,0 +1,13 @@
+class ProconBypassMan::SuppressRumble
+  # @param [String] binary
+  def initialize(binary: )
+    @binary = binary
+  end
+
+  # @return [String]
+  def execute
+    new_raw = ["100c0001404000014040"].pack("H*")
+    new_raw[1] = @binary[1]
+    new_raw
+  end
+end

data/lib/procon_bypass_man/procon/user_operation.rb

@@ -33,22 +33,22 @@ class ProconBypassMan::Procon::UserOperation
     binary.write_as_press_button(button)
   end
 
-  # @param [Symbol, Array<Symbol>] button
-  def press_button_only(button)
-    if button.is_a?(Array)
-      binary.set_no_action!
-      button.uniq.each do |b|
-        unless ProconBypassMan::Procon::MacroBuilder::RESERVED_WORD_NONE == b
-          binary.write_as_press_button(b)
-        end
-      end
-      return
-    end
+  # @param [Symbol, Array<Symbol>] macro_step
+  def press_button_only_or_tilt_sticks(macro_step)
+    macro_step = [macro_step] if not macro_step.is_a?(Array)
+    # スティック操作の時はボタン入力を通す
+    binary.set_no_action! if is_button?(macro_step)
+
+    macro_step.uniq.each do |ms|
+      next if ProconBypassMan::Procon::MacroBuilder::RESERVED_WORD_NONE == ms
 
-    if ProconBypassMan::Procon::MacroBuilder::RESERVED_WORD_NONE == button
-      binary.set_no_action!
-    else
-      binary.write_as_press_button_only(button)
+      if is_button?(ms)
+        binary.write_as_press_button(ms)
+      elsif is_stick?(ms)
+        binary.write_as_tilt_left_stick(ms)
+      else
+        warn "知らないmacro stepです"
+      end
     end
   end
 
@@ -62,7 +62,7 @@ class ProconBypassMan::Procon::UserOperation
   # @param [Symbol] button
   # @return [Boolean]
   def pressing_button?(button)
-    ProconBypassMan::PressButtonAware.new(@binary.raw).pressing_button?(button)
+    pressing_all_buttons?([button])
   end
 
   # @param [Array<Symbol>] buttons
@@ -71,4 +71,18 @@ class ProconBypassMan::Procon::UserOperation
     aware = ProconBypassMan::PressButtonAware.new(@binary.raw)
     buttons.all? { |b| aware.pressing_button?(b) }
   end
+
+  # @return [Boolean]
+  def is_button?(button)
+    button = [button] if not button.is_a?(Array)
+
+    button.all? do |b|
+      !!ProconBypassMan::Procon::ButtonCollection::BUTTONS_MAP[b.to_sym] || b.to_sym == ProconBypassMan::Procon::MacroBuilder::RESERVED_WORD_NONE
+    end
+  end
+
+  # @return [Boolean]
+  def is_stick?(step)
+    !!(step =~ /\Atilt_/)
+  end
 end

data/lib/procon_bypass_man/procon/value_objects/analog_stick.rb

@@ -1,6 +1,6 @@
 class ProconBypassMan::Procon::AnalogStick
   attr_accessor :neutral_position
-  attr_accessor :bin_x, :bin_y
+  attr_writer :bin_x, :bin_y
 
   def initialize(binary: )
     @neutral_position = ProconBypassMan::ButtonsSettingConfiguration.instance.neutral_position
@@ -13,18 +13,22 @@ class ProconBypassMan::Procon::AnalogStick
   end
 
   def abs_x
-    bin_x.to_i(2)
+    @bin_x.to_i(2)
   end
 
   def abs_y
-    bin_y.to_i(2)
+    @bin_y.to_i(2)
   end
 
   def relative_x
-    bin_x.to_i(2) - neutral_position.x
+    @bin_x.to_i(2) - neutral_position.x
   end
 
   def relative_y
-    bin_y.to_i(2) - neutral_position.y
+    @bin_y.to_i(2) - neutral_position.y
+  end
+
+  def relative_hypotenuse
+    Math.sqrt((relative_x**2) + (relative_y**2)).floor(6)
   end
 end

data/lib/procon_bypass_man/procon/value_objects/analog_stick_position.rb

@@ -0,0 +1,18 @@
+class ProconBypassMan::AnalogStickPosition
+  attr_accessor :x, :y
+
+  def initialize(x:, y:)
+    @x = x.to_i
+    @y = y.to_i
+  end
+
+  def to_binary
+    analog_stick_data = [
+      (@x & "0xff".to_i(16)),
+      ((@y << 4) & "0xf0".to_i(16)) | ((@x >> 8) & "0x0f".to_i(16)),
+      (@y >> 4) & "0xff".to_i(16),
+    ]
+    hex = analog_stick_data.map{ |x| x.to_s(16).rjust(2, "0") }.join
+    [hex].pack("H*")
+  end
+end

data/lib/procon_bypass_man/{domains → procon/value_objects}/binary/inbound_procon_binary.rb

@@ -6,4 +6,9 @@ class ProconBypassMan::Domains::InboundProconBinary < ProconBypassMan::Domains::
   def user_operation_data?
     binary[0] == "\x30".b
   end
+
+  # @return [Boolean]
+  def rumble_data?
+    binary[0] == "\x10".b
+  end
 end

data/lib/procon_bypass_man/{domains → procon/value_objects}/binary/processing_procon_binary.rb

@@ -36,16 +36,21 @@ class ProconBypassMan::Domains::ProcessingProconBinary < ProconBypassMan::Domain
 
   # @param [Symbol] button
   def write_as_press_button(button)
-    raise "already pressing button(#{button})" if ProconBypassMan::PressButtonAware.new(binary).pressing_button?(button)
+    return if ProconBypassMan::PressButtonAware.new(binary).pressing_button?(button)
 
     button_obj = ProconBypassMan::Procon::Button.new(button)
     value = binary[button_obj.byte_position].unpack("C").first + (2**button_obj.bit_position)
     binary[button_obj.byte_position] = ["%02X" % value.to_s].pack("H*")
   end
 
+  # @param [Symbol] stick method
+  def write_as_tilt_left_stick(step)
+    binary[6..8] = ProconBypassMan::Procon::AnalogStickManipulator.new(binary, method: step).to_binary
+  end
+
   # @param [Symbol] button
   def write_as_unpress_button(button)
-    raise "not press button(#{button}) yet" if not ProconBypassMan::PressButtonAware.new(binary).pressing_button?(button)
+    raise "do not press button(#{button}) yet" if not ProconBypassMan::PressButtonAware.new(binary).pressing_button?(button)
 
     button_obj = ProconBypassMan::Procon::Button.new(button)
     value = binary[button_obj.byte_position].unpack("C").first - (2**button_obj.bit_position)

data/lib/procon_bypass_man/procon/value_objects/binary.rb

@@ -0,0 +1,11 @@
+module ProconBypassMan
+  module Domains
+    module Binary; end
+  end
+end
+
+require "procon_bypass_man/procon/value_objects/binary/base"
+require "procon_bypass_man/procon/value_objects/binary/has_immutable_binary"
+require "procon_bypass_man/procon/value_objects/binary/has_mutable_binary"
+require "procon_bypass_man/procon/value_objects/binary/inbound_procon_binary"
+require "procon_bypass_man/procon/value_objects/binary/processing_procon_binary"

data/lib/procon_bypass_man/procon/value_objects/rumble_binary.rb

@@ -0,0 +1,18 @@
+class ProconBypassMan::RumbleBinary
+  # @param [String] binary
+  def initialize(binary: )
+    @binary = binary
+  end
+
+  def unpack
+    @binary.unpack("H*")
+  end
+
+  def noop!
+    @binary = ProconBypassMan::SuppressRumble.new(binary: @binary).execute
+  end
+
+  def raw
+    @binary
+  end
+end