procon_bypass_man 0.1.20.2 → 0.1.23

data/lib/procon_bypass_man/bypass.rb

@@ -1,13 +1,12 @@
 require "procon_bypass_man/bypass/usb_hid_logger"
-require "procon_bypass_man/bypass/bypass_mode"
 
 class ProconBypassMan::Bypass
   include ProconBypassMan::Bypass::UsbHidLogger
 
-  class BypassValue < Struct.new(:binary, :sent)
+  class BypassValue < Struct.new(:binary)
     def to_text
       return unless binary
-      "#{binary.unpack.first} #{'x' unless sent}"
+      binary.unpack.first
     end
   end
 
@@ -22,23 +21,32 @@ class ProconBypassMan::Bypass
   # ゆっくりでいい
   def send_gadget_to_procon!
     monitor.record(:start_function)
-    input = nil
-    self.bypass_value = BypassValue.new(nil, sent = false)
+    self.bypass_value = BypassValue.new(nil)
 
     run_callbacks(:send_gadget_to_procon) do
+      break if $will_terminate_token
+
+      raw_input = nil
       begin
-        break if $will_terminate_token
         # TODO blocking readにしたいが、接続時のフェーズによって長さが違うので厳しい
-        input = self.gadget.read_nonblock(64)
-        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: input)
+        raw_input = self.gadget.read_nonblock(64)
+        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_input)
       rescue IO::EAGAINWaitReadable
         monitor.record(:eagain_wait_readable_on_read)
       end
 
-      if input
+      if self.bypass_value.binary
         begin
-          self.procon.write_nonblock(input)
-          self.bypass_value.sent = true
+          raw_data =
+            case
+            when self.bypass_value.binary.rumble_data?
+              binary = ProconBypassMan::RumbleBinary.new(binary: self.bypass_value.binary.raw)
+              binary.noop!
+              binary.raw
+            else
+              self.bypass_value.binary.raw
+            end
+          self.procon.write_nonblock(raw_data)
         rescue IO::EAGAINWaitReadable
           monitor.record(:eagain_wait_readable_on_write)
           break
@@ -51,15 +59,15 @@ class ProconBypassMan::Bypass
 
   def send_procon_to_gadget!
     monitor.record(:start_function)
-    output = nil
-    self.bypass_value = BypassValue.new(nil, sent = false)
+    self.bypass_value = BypassValue.new(nil)
 
     run_callbacks(:send_procon_to_gadget) do
+      break if $will_terminate_token
+
       begin
-        break if $will_terminate_token
         Timeout.timeout(1) do
-          output = self.procon.read(64)
-          self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: output)
+          raw_output = self.procon.read(64)
+          self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_output)
         end
       rescue Timeout::Error
         ProconBypassMan.logger.debug { "read timeout! do sleep. by send_procon_to_gadget!" }
@@ -74,16 +82,10 @@ class ProconBypassMan::Bypass
         retry
       end
 
-      # blocking readをしているのでnilが入ることはないが、雑なテストでnilが通るので分岐を入れる。できれば消したい
-      break if output.nil?
-
       begin
         self.gadget.write_nonblock(
-          ProconBypassMan::Processor.new(
-            ProconBypassMan::Domains::InboundProconBinary.new(binary: output)
-          ).process
+          ProconBypassMan::Processor.new(bypass_value.binary).process
         )
-        self.bypass_value.sent = true
       rescue IO::EAGAINWaitReadable
         monitor.record(:eagain_wait_readable_on_write)
         break
@@ -91,4 +93,24 @@ class ProconBypassMan::Bypass
     end
     monitor.record(:end_function)
   end
+
+  # @return [void]
+  def direct_connect_switch_via_bluetooth
+    ProconBypassMan.logger.debug { "direct_connect_switch_via_bluetooth!" }
+    self.procon.write_nonblock(["8005"].pack("H*"))
+    self.procon.write_nonblock(["8005"].pack("H*"))
+    self.procon.write_nonblock(["8005"].pack("H*"))
+  end
+
+  # @return [void] 入力してから取り出さないと接続しっぱなしになるっぽいのでこれが必要っぽい
+  def be_empty_procon
+    timer = ProconBypassMan::SafeTimeout.new(timeout: Time.now + 5)
+    loop do
+      break if timer.timeout?
+      output = self.procon.read_nonblock(64)
+      ProconBypassMan.logger.debug { "[ProconBypassMan::Bypass#be_empty_procon] #{output.unpack("H*").first}" }
+    rescue IO::EAGAINWaitReadable
+      # no-op
+    end
+  end
 end

data/lib/procon_bypass_man/commands/bypass_command.rb

@@ -1,6 +1,11 @@
 class ProconBypassMan::BypassCommand
   include ProconBypassMan::SignalHandler
 
+  module WILL_TERMINATE_TOKEN
+    TERMINATE = :terminate
+    RESTART = :restart
+  end
+
   def initialize(gadget:, procon:)
     @gadget = gadget
     @procon = procon
@@ -12,7 +17,7 @@ class ProconBypassMan::BypassCommand
 
   def execute
     self_read, self_write = IO.pipe
-    %w(TERM INT).each do |sig|
+    %w(TERM INT USR2).each do |sig|
       begin
         trap sig do
           self_write.puts(sig)
@@ -28,17 +33,19 @@ class ProconBypassMan::BypassCommand
     monitor2 = ProconBypassMan::IOMonitor.new(label: "procon -> switch")
     ProconBypassMan.logger.info "Thread1を起動します"
 
-    @send_interval = 0.005
+    cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 0.005, execution_cycle: 0)
 
     t1 = Thread.new do
       timer = ProconBypassMan::SafeTimeout.new(timeout: Time.now + 10)
       @did_first_step = false
       loop do
-        bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor1)
         break if $will_terminate_token
-        !@did_first_step && timer.throw_if_timeout!
-        bypass.send_gadget_to_procon!
-        sleep(@send_interval)
+
+        cycle_sleep.sleep_or_execute do
+          bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor1)
+          !@did_first_step && timer.throw_if_timeout!
+          bypass.send_gadget_to_procon!
+        end
       rescue ProconBypassMan::SafeTimeout::Timeout
         case ProconBypassMan.config.bypass_mode.mode
         when ProconBypassMan::BypassMode::TYPE_AGGRESSIVE
@@ -47,7 +54,7 @@ class ProconBypassMan::BypassCommand
           break
         when ProconBypassMan::BypassMode::TYPE_NORMAL
           ProconBypassMan.logger.info "10秒経過したのでsend_intervalを長くします"
-          @send_interval = ProconBypassMan.config.bypass_mode.gadget_to_procon_interval
+          cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 1, execution_cycle: ProconBypassMan.config.bypass_mode.gadget_to_procon_interval)
         else
           raise "unknown type"
         end
@@ -69,7 +76,14 @@ class ProconBypassMan::BypassCommand
     t2 = Thread.new do
       bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor2)
       loop do
-        break if $will_terminate_token
+        if $will_terminate_token
+          if $will_terminate_token == WILL_TERMINATE_TOKEN::TERMINATE
+            bypass.direct_connect_switch_via_bluetooth
+            bypass.be_empty_procon
+          end
+          break
+        end
+
         bypass.send_procon_to_gadget!
       rescue EOFError => e
         ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します. #{e.full_message}")
@@ -87,12 +101,18 @@ class ProconBypassMan::BypassCommand
         signal = readable_io.first[0].gets.strip
         handle_signal(signal)
       end
+    rescue ProconBypassMan::Runner::InterruptForRestart
+      $will_terminate_token = WILL_TERMINATE_TOKEN::RESTART
+      [t1, t2].each(&:join)
+      @gadget&.close
+      @procon&.close
+      exit! 1 # child processなのでexitしていい
     rescue Interrupt
-      $will_terminate_token = true
+      $will_terminate_token = WILL_TERMINATE_TOKEN::TERMINATE
       [t1, t2].each(&:join)
       @gadget&.close
       @procon&.close
-      exit 1 # child processなのでexitしていい
+      exit! 1 # child processなのでexitしていい
     end
   end
 end

data/lib/procon_bypass_man/commands/print_boot_message_command.rb

@@ -42,7 +42,7 @@ class ProconBypassMan::PrintBootMessageCommand
       uptime from boot: #{@table[:uptime_from_boot]} sec
       use_pbmenv: #{@table[:use_pbmenv]}
       session_id: #{ProconBypassMan.session_id}
-      device_id: #{ProconBypassMan.device_id}
+      device_id: #{ProconBypassMan.device_id.gsub(/.{25}$/, "*"*25)}
       bypass_mode: #{ProconBypassMan.config.bypass_mode}
       ----
       EOF

data/lib/procon_bypass_man/configuration.rb

@@ -156,7 +156,14 @@ class ProconBypassMan::Configuration
   end
 
   # @return [Boolean]
-  def enable_ws?; !!current_server; end
+  def enable_ws?
+    !!current_server
+  end
+
+  # @return [Boolean]
+  def enable_remote_macro?
+    enable_ws?
+  end
 
   # @return [Array<String>]
   def api_servers

data/lib/procon_bypass_man/device_connector.rb

@@ -1,25 +1,27 @@
+require "timeout"
+
 class ProconBypassMan::DeviceConnector
   class BytesMismatchError < StandardError; end
   class NotFoundProconError < StandardError; end
 
   class Value
-    attr_accessor :read_from, :values
-    def initialize(values: , read_from: )
+    attr_accessor :read_from, :values, :call_block_if_receive, :block
+
+    def initialize(values: , read_from: , call_block_if_receive: false, &block)
       @values = values
       @read_from = read_from
+      @call_block_if_receive = call_block_if_receive
+      @block = block
     end
   end
 
-  PROCON_PATH = "/dev/hidraw0"
-  PROCON2_PATH = "/dev/hidraw1"
-
   def self.connect
-    s = new(throw_error_if_timeout: true, enable_at_exit: false)
+    s = new(throw_error_if_timeout: true)
     s.add([
       ["0000"],
       ["0000"],
       ["8005"],
-      ["0010"],
+      ["0000"],
     ], read_from: :switch)
     # 1. Sends current connection status, and if the Joy-Con are connected,
     s.add([["8001"]], read_from: :switch)
@@ -29,23 +31,30 @@ class ProconBypassMan::DeviceConnector
     s.add([/^8102/], read_from: :procon)
     # 3
     s.add([/^0100/], read_from: :switch)
-    s.add([/^21/], read_from: :procon)
+    s.add([/^21/], read_from: :procon, call_block_if_receive: /^8101/) do |this|
+      ProconBypassMan.logger.info "(start special route)"
+      this.blocking_read_with_timeout_from_procon # <<< 810100032dbd42e9b698000
+      this.write_to_procon("8002")
+      this.blocking_read_with_timeout_from_procon # <<< 8102
+      this.write_to_procon("01000000000000000000033000000000000000000000000000000000000000000000000000000000000000000000000000")
+      this.blocking_read_with_timeout_from_procon # <<< 21
+    end
+
     # 4. Forces the Joy-Con or Pro Controller to only talk over USB HID without any timeouts. This is required for the Pro Controller to not time out and revert to Bluetooth.
     s.add([["8004"]], read_from: :switch)
     s.drain_all
     return [s.switch, s.procon]
   end
 
-  def initialize(throw_error_if_timeout: false, throw_error_if_mismatch: false , enable_at_exit: true)
-    @stack = []
+  def initialize(throw_error_if_timeout: false, throw_error_if_mismatch: false)
+    @queue = []
     @initialized_devices = false
     @throw_error_if_timeout = throw_error_if_timeout
     @throw_error_if_mismatch = throw_error_if_mismatch
-    @enable_at_exit = enable_at_exit
   end
 
-  def add(values, read_from: )
-    @stack << Value.new(values: values, read_from: read_from)
+  def add(values, read_from: , call_block_if_receive: false, &block)
+    @queue << Value.new(values: values, read_from: read_from, call_block_if_receive: call_block_if_receive, &block)
   end
 
   def drain_all
@@ -54,181 +63,47 @@ class ProconBypassMan::DeviceConnector
       init_devices
     end
 
-    while(item = @stack.shift)
+    while(item = @queue.shift)
       item.values.each do |value|
-        data = nil
+        raw_data = nil
         timer = ProconBypassMan::SafeTimeout.new
         begin
           timer.throw_if_timeout!
-          data = from_device(item).read_nonblock(64)
-          debug_log_buffer << "read_from(#{item.read_from}): #{data.unpack("H*")}"
+          raw_data = from_device(item).read_nonblock(64)
+          debug_log_buffer << "read_from(#{item.read_from}): #{raw_data.unpack("H*")}"
         rescue IO::EAGAINWaitReadable
           # debug_log_buffer << "read_from(#{item.read_from}): IO::EAGAINWaitReadable"
           retry
         end
 
+        if item.call_block_if_receive =~ raw_data.unpack("H*").first
+          raw_data = item.block.call(self)
+        end
+
         result =
           case value
           when String, Array
-            value == data.unpack("H*")
+            value == raw_data.unpack("H*")
           when Regexp
-            value =~ data.unpack("H*").first
+            value =~ raw_data.unpack("H*").first
           else
             raise "#{value}は知りません"
           end
         if result
-          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{data.unpack("H*")})"
-          debug_log_buffer << "OK(expected: #{value}, got: #{data.unpack("H*")})"
+          ProconBypassMan.logger.info "OK(expected: #{value}, got: #{raw_data.unpack("H*")})"
+          debug_log_buffer << "OK(expected: #{value}, got: #{raw_data.unpack("H*")})"
         else
-          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{data.unpack("H*")})"
-          debug_log_buffer << "NG(expected: #{value}, got: #{data.unpack("H*")})"
-          raise BytesMismatchError if @throw_error_if_mismatch
+          ProconBypassMan.logger.info "NG(expected: #{value}, got: #{raw_data.unpack("H*")})"
+          debug_log_buffer << "NG(expected: #{value}, got: #{raw_data.unpack("H*")})"
+          raise BytesMismatchError.new(debug_log_buffer) if @throw_error_if_mismatch
         end
-        to_device(item).write_nonblock(data)
+        to_device(item).write_nonblock(raw_data)
       end
     end
-  rescue ProconBypassMan::SafeTimeout::Timeout
-    ProconBypassMan.logger.error "timeoutになりました"
-    copressed_buffer_text = ProconBypassMan::CompressArray.new(debug_log_buffer).compress.join("\n")
-    ProconBypassMan::SendErrorCommand.execute(error: copressed_buffer_text)
-    raise if @throw_error_if_timeout
-  end
-
-  # switchに任意の命令を入力して、switchから読み取る
-  def write_switch(data, only_write: false)
-    if data.encoding.name == "UTF-8"
-      data = [data].pack("H*")
-    end
-    unless @initialized_devices
-      init_devices
-    end
-
-    timer = ProconBypassMan::SafeTimeout.new
-    data = nil
-    begin
-      timer.throw_if_timeout!
-      switch.write_nonblock(data)
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "writeでtimeoutになりました"
-      raise
-    end
-    return(data.unpack("H*")) if only_write
-
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      data = switch.read_nonblock(64)
-      ProconBypassMan.logger.debug { " >>> #{data.unpack("H*")})" }
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "readでtimeoutになりました"
-      raise
-    end
-  rescue ProconBypassMan::SafeTimeout::Timeout
-    raise if @throw_error_if_timeout
-  end
-
-  def write_procon(data, only_write: false)
-    if data.encoding.name == "UTF-8"
-      data = [data].pack("H*")
-    end
-    unless @initialized_devices
-      init_devices
-    end
-
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      procon.write_nonblock(data)
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "writeでtimeoutになりました"
-      raise
-    end
-    return(data.unpack("H*")) if only_write
-
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      data = procon.read_nonblock(64)
-      ProconBypassMan.logger.error " <<< #{data.unpack("H*")})"
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "readでtimeoutになりました"
-      raise
-    end
-  rescue ProconBypassMan::SafeTimeout::Timeout
-    raise if @throw_error_if_timeout
-  end
-
-  def read_procon(only_read: false)
-    unless @initialized_devices
-      init_devices
-    end
-
-    data = nil
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      data = procon.read_nonblock(64)
-      ProconBypassMan.logger.debug { " <<< #{data.unpack("H*")})" }
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "readでtimeoutになりました"
-      raise
-    end
-    return(data.unpack("H*")) if only_read
-
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      switch.write_nonblock(data)
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "writeでtimeoutになりました"
-      raise
-    end
-  rescue ProconBypassMan::SafeTimeout::Timeout
-    raise if @throw_error_if_timeout
-  end
-
-  def read_switch(only_read: false)
-    unless @initialized_devices
-      init_devices
-    end
-
-    data = nil
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      data = switch.read_nonblock(64)
-      ProconBypassMan.logger.debug { " >>> #{data.unpack("H*")})" }
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "readでtimeoutになりました"
-      raise
-    end
-    return(data.unpack("H*")) if only_read
-
-    timer = ProconBypassMan::SafeTimeout.new
-    begin
-      timer.throw_if_timeout!
-      procon.write_nonblock(data)
-    rescue IO::EAGAINWaitReadable
-      retry
-    rescue ProconBypassMan::SafeTimeout::Timeout
-      ProconBypassMan.logger.error "writeでtimeoutになりました"
-      raise
-    end
-  rescue ProconBypassMan::SafeTimeout::Timeout
+  rescue ProconBypassMan::SafeTimeout::Timeout, Timeout::Error => e
+    ProconBypassMan.logger.error "timeoutになりました(#{e.message})"
+    compressed_buffer_text = ProconBypassMan::CompressArray.new(debug_log_buffer).compress.join("\n")
+    ProconBypassMan::SendErrorCommand.execute(error: compressed_buffer_text)
     raise if @throw_error_if_timeout
   end
 
@@ -280,17 +155,23 @@ class ProconBypassMan::DeviceConnector
     ProconBypassMan::UsbDeviceController.reset
 
     @initialized_devices = true
-
-    if @enable_at_exit
-      at_exit do
-        @procon&.close
-        @gadget&.close
-      end
-    end
   rescue Errno::ENXIO => e
     # /dev/hidg0 をopenできないときがある
     ProconBypassMan::SendErrorCommand.execute(error: "Errno::ENXIO (No such device or address @ rb_sysopen - /dev/hidg0)が起きました。resetします.\n #{e.full_message}")
     ProconBypassMan::UsbDeviceController.reset
     retry
   end
+
+  def blocking_read_with_timeout_from_procon
+    Timeout.timeout(4) do
+      raw_data = procon.read(64)
+      ProconBypassMan.logger.info "<<< #{raw_data.unpack("H*").first}"
+      return raw_data
+    end
+  end
+
+  def write_to_procon(data)
+    ProconBypassMan.logger.info ">>> #{data}"
+    procon.write_nonblock([data].pack("H*"))
+  end
 end

data/lib/procon_bypass_man/plugin/splatoon2/macro/charge_tansan_bomb.rb

@@ -0,0 +1,21 @@
+module ProconBypassMan
+  module Plugin
+    module Splatoon2
+      module Macro
+        module ChargeTansanBomb
+          def self.display_name
+            :charge_tansan_bomb
+          end
+
+          def self.steps
+            [:shake_left_stick_and_toggle_b_for_0_1sec].freeze
+          end
+
+          def self.description
+            'タンサンボムのチャージ'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/plugin/splatoon2/macro/dasei_cancel.rb

@@ -0,0 +1,21 @@
+module ProconBypassMan
+  module Plugin
+    module Splatoon2
+      module Macro
+        module DaseiCancel
+          def self.display_name
+            :dasei_cancel
+          end
+
+          def self.steps
+            [:pressing_r_for_0_03sec, :pressing_r_and_pressing_zl_for_0_2sec].freeze
+          end
+
+          def self.description
+            '惰性キャンセル'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/plugin/splatoon2/version.rb

@@ -3,7 +3,7 @@
 module ProconBypassMan
   module Plugin
     module Splatoon2
-      VERSION = "0.1.3"
+      VERSION = "0.1.5"
     end
   end
 end

data/lib/procon_bypass_man/plugins.rb

@@ -4,6 +4,8 @@ require_relative "plugin/splatoon2/macro/jump_to_right_key"
 require_relative "plugin/splatoon2/macro/jump_to_up_key"
 require_relative "plugin/splatoon2/macro/jump_to_left_key"
 require_relative "plugin/splatoon2/macro/sokuwari_for_splash_bomb"
+require_relative "plugin/splatoon2/macro/dasei_cancel"
+require_relative "plugin/splatoon2/macro/charge_tansan_bomb"
 require_relative "plugin/splatoon2/mode/guruguru"
 
 module ProconBypassMan

data/lib/procon_bypass_man/procon/analog_stick_cap.rb

@@ -1,36 +1,17 @@
 class ProconBypassMan::Procon::AnalogStickCap
-  class Position
-    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
-
   def initialize(binary)
     @binary = binary
     @analog_stick = ProconBypassMan::Procon::AnalogStick.new(binary: binary)
   end
 
-  # @return [ProconBypassMan::Procon::AnalogStickCap::Position]
+  # @return [ProconBypassMan::AnalogStickPosition]
   def capped_position(cap_hypotenuse: )
     if hypotenuse > cap_hypotenuse
       relative_capped_x = cap_hypotenuse * Math.cos(rad * Math::PI / 180).abs
       relative_capped_y = cap_hypotenuse * Math.sin(rad * Math::PI / 180).abs
       relative_capped_x = -(relative_capped_x.abs) if relative_x.negative?
       relative_capped_y = -(relative_capped_y.abs) if relative_y.negative?
-      return Position.new(
+      return ProconBypassMan::AnalogStickPosition.new(
         x: relative_capped_x + @analog_stick.neutral_position.x,
         y: relative_capped_y + @analog_stick.neutral_position.y,
       )
@@ -39,9 +20,9 @@ class ProconBypassMan::Procon::AnalogStickCap
     end
   end
 
-  # @return [ProconBypassMan::Procon::AnalogStickCap::Position]
+  # @return [ProconBypassMan::AnalogStickPosition]
   def position
-    Position.new(x: abs_x, y: abs_y)
+    ProconBypassMan::AnalogStickPosition.new(x: abs_x, y: abs_y)
   end
 
   def abs_x; @analog_stick.abs_x; end # 0, 0からのx