extended input error

class Scene_Test < Scene_Base

  def start
    super
  end

  def update
    super
    $ctrl.flip_mode if $ctrl.trigger_help
    p($ctrl.key_any?)   # <---------------------------------this produces  key.trigger? == true  every other frame when "key.press?"
  end



###############################
my script using extended input system
###############################

class Game_Input
  attr_reader :up
  attr_reader :down
  attr_reader :left
  attr_reader :right
  attr_reader :up_left
  attr_reader :up_right
  attr_reader :down_left
  attr_reader :down_right
  attr_accessor :pgup                           # page up
  attr_accessor :pgdn                           # page down
  attr_accessor :pglf                           # page left
  attr_accessor :pgrt                           # page right
  attr_accessor :pause                          # toggle pause
  attr_accessor :help                           # toggle help windows etc..
  attr_accessor :ok                             # (ok / attack)
  attr_accessor :cancel                         # (cancel / run)
  attr_accessor :menu                           # (menu / exit menu)
  attr_accessor :ability                        # use equipped (ability / item)
  attr_accessor :wait_time                      # time between input proccessing

  attr_accessor :new_assignment                 # temp slot for key binding

  def initialize
    @wait_time = 5
    @wait = 0
    @new_assignment = nil
    set_mode(Keyboard)
    @joys = {:up      => :UP,
             :down    => :DOWN,
             :left    => :LEFT,
             :right   => :RIGHT,
             :ok      => :JOY2,
             :cancel  => :JOY3,
             :menu    => :JOY1,
             :ability => :JOY4,       #<- Rename(action, interact, ?...
             :pgup    => :JOY5,
             :pgdn    => :JOY6,
             :pglf    => :JOY7,
             :pgrt    => :JOY8,
             :help    => :JOY9,
             :pause   => :JOY10
    }
    @keys = {:up      => :UP,
             :down    => :DOWN,
             :left    => :LEFT,
             :right   => :RIGHT,
             :ok      => :X,
             :cancel  => :Z,
             :menu    => :S,
             :ability => :A,       #<- Rename(action, interact, ?...
             :pgup    => :PAGE_UP,
             :pgdn    => :PAGE_DOWN,
             :pglf    => :Q,
             :pgrt    => :W,
             :help    => :H,
             :pause   => :SPACE
    }
  end

  def update
    @wait -= 1 if @wait > 0
    @wait = @wait_time if ready? && any_input?
  end

  def ready?
    @wait == 0
  end

  def any_input?
    return true if trigger_up
    return true if trigger_down
    return true if trigger_left
    return true if trigger_right
    return true if trigger_ok
    return true if trigger_cancel
    return true if trigger_menu
    return true if trigger_ability
    return true if trigger_page_up
    return true if trigger_page_down
    return true if trigger_page_left
    return true if trigger_page_right
    return true if trigger_help
    return true if trigger_pause
    return false
  end



  def button
    if @device == Keyboard
      @keys
    else
      @joys
    end
  end

  def set_mode(device)
    @device = device
  end

  def flip_mode
    @device == Keyboard ? set_mode(Gamepad[1]) : set_mode(Keyboard)
  end

#-------------------------------------------------------------------------------
# - BUTTONS (trigger)
#_______________________________________________________________________________

  def trigger_up
    @device.trigger?(button[:up])
  end

  def trigger_down
    @device.trigger?(button[:down])
  end

  def trigger_left
    @device.trigger?(button[:left])
  end

  def trigger_right
    @device.trigger?(button[:right])
  end

  def trigger_ok
    @device.trigger?(button[:ok])
  end

  def trigger_cancel
    @device.trigger?(button[:cancel])
  end

  def trigger_menu
    @device.trigger?(button[:menu])
  end

  def trigger_ability
    @device.trigger?(button[:ability])
  end

  def trigger_page_up
    @device.trigger?(button[:pgup])
  end

  def trigger_page_down
    @device.trigger?(button[:pgdn])
  end

  def trigger_page_left
    @device.trigger?(button[:pglf])
  end

  def trigger_page_right
    @device.trigger?(button[:pgrt])
  end

  def trigger_help
    @device.trigger?(button[:help])
  end

  def trigger_pause
    @device.trigger?(button[:pause])
  end

#-------------------------------------------------------------------------------
# - BUTTONS (press)
#_______________________________________________________________________________

  def press_up
    @device.press?(button[:up])
  end

  def press_down
    @device.press?(button[:down])
  end

  def press_left
    @device.press?(button[:left])
  end

  def press_right
    @device.press?(button[:right])
  end

  def press_ok
    @device.press?(button[:ok])
  end

  def press_cancel
    @device.press?(button[:cancel])
  end

  def press_menu
    @device.press?(button[:menu])
  end

  def press_ability
    @device.press?(button[:ability])
  end

  def press_page_up
    @device.press?(button[:pgup])
  end

  def press_page_down
    @device.press?(button[:pgdn])
  end

  def press_page_left
    @device.press?(button[:pglf])
  end

  def press_page_right
    @device.press?(button[:pgrt])
  end

  def press_help
    @device.press?(button[:help])
  end

  def press_pause
    @device.press?(button[:pause])
  end

#-------------------------------------------------------------------------------
# - BUTTONS (repeat)
#_______________________________________________________________________________

  def repeat_up
    @device.repeat?(button[:up])
  end

  def repeat_down
    @device.repeat?(button[:down])
  end

  def repeat_left
    @device.repeat?(button[:left])
  end

  def repeat_right
    @device.repeat?(button[:right])
  end

  def repeat_ok
    @device.repeat?(button[:ok])
  end

  def repeat_cancel
    @device.repeat?(button[:cancel])
  end

  def repeat_menu
    @device.repeat?(button[:menu])
  end

  def repeat_ability
    @device.repeat?(button[:ability])
  end

  def repeat_page_up
    @device.repeat?(button[:pgup])
  end

  def repeat_page_down
    @device.repeat?(button[:pgdn])
  end

  def repeat_page_left
    @device.repeat?(button[:pglf])
  end

  def repeat_page_right
    @device.repeat?(button[:pgrt])
  end

  def repeat_help
    @device.repeat?(button[:help])
  end

  def repeat_pause
    @device.repeat?(button[:pause])
  end

#-------------------------------------------------------------------------------
# - BUTTONS (release)
#_______________________________________________________________________________

  def release_up
    @device.release?(button[:up])
  end

  def release_down
    @device.release?(button[:down])
  end

  def release_left
    @device.release?(button[:left])
  end

  def release_right
    @device.release?(button[:right])
  end

  def release_ok
    @device.release?(button[:ok])
  end

  def release_cancel
    @device.release?(button[:cancel])
  end

  def release_menu
    @device.release?(button[:menu])
  end

  def release_ability
    @device.release?(button[:ability])
  end

  def release_page_up
    @device.release?(button[:pgup])
  end

  def release_page_down
    @device.release?(button[:pgdn])
  end

  def release_page_left
    @device.release?(button[:pglf])
  end

  def release_page_right
    @device.release?(button[:pgrt])
  end

  def release_help
    @device.release?(button[:help])
  end

  def release_pause
    @device.release?(button[:pause])
  end

  def key_any?
    key_trigs = []
    key_trigs << :ok      if @device.trigger?(button[:ok])
    key_trigs << :cancel  if @device.trigger?(button[:cancel])
    key_trigs << :menu    if @device.trigger?(button[:menu])
    key_trigs << :ability if @device.trigger?(button[:ability])
    key_trigs << :pgup    if @device.trigger?(button[:pgup])
    key_trigs << :pgdn    if @device.trigger?(button[:pgdn])
    key_trigs << :pglf    if @device.trigger?(button[:pglf])
    key_trigs << :pgrt    if @device.trigger?(button[:pgrt])
    key_trigs << :help    if @device.trigger?(button[:help])
    key_trigs << :pause   if @device.trigger?(button[:pause])
    key_trigs
  end
end