Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 3768 miembros registrados.
El último usuario registrado es lMac.

Nuestros miembros han publicado un total de 85831 mensajes en 12224 argumentos.

Script para usar ratón.

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP Script para usar ratón.

Mensaje por MaddManu el 2013-01-27, 23:43

Gente del mundillo, os traigo un Script que permite usar el ratón para jugar a Rpg Maker. Es totalmente funcional y si teneis problemas, serán vuestros no del script xD

Están realizados por Near Fantastica & SephirothSpawn.

Spoiler:

Código:
module StartGame

  $game_mouse = true
 
end


Código:
#==============================================================================
# ** Modules.Mouse Input (7.0)              By Near Fantastica & SephirothSpawn
#==============================================================================
module Mouse
  #--------------------------------------------------------------------------
  # * Mouse to Input Triggers
  #
  #  key => Input::KeyCONSTANT (key: 0 - Left, 1 - Middle, 2 - Right)
  #--------------------------------------------------------------------------
  Mouse_to_Input_Triggers = {0 => Input::C, 1 => Input::B, 2 => Input::A}
  #--------------------------------------------------------------------------
  # * API Declaration
  #--------------------------------------------------------------------------
  GAKS          = Win32API.new('user32',    'GetAsyncKeyState', 'i',    'i')
  GSM          = Win32API.new('user32',    'GetSystemMetrics', 'i',    'i')
  Cursor_Pos    = Win32API.new('user32',    'GetCursorPos',    'p',    'i')
  $ShowCursor  = Win32API.new('user32',    'ShowCursor',      'i',    'l')
  Scr2cli      = Win32API.new('user32',    'ScreenToClient',  %w(l p), 'i')
  Client_rect  = Win32API.new('user32',    'GetClientRect',    %w(l p), 'i')
  Findwindow    = Win32API.new('user32',    'FindWindowA',      %w(p p), 'l')
  Readini      = Win32API.new('kernel32',  'GetPrivateProfileStringA',
                              %w(p p p p l p), 'l')
                             
  # if graphical effects turned on, show fancy cursor
  $ShowCursor.call($game_mouse ? 0 : 1)
 
  @triggers    =  [[0, 1], [0, 2], [0, 4]]
  @old_pos      =  0
  @pos_i        =  0
   
  #--------------------------------------------------------------------------
  # * Mouse Grid Position
  #--------------------------------------------------------------------------
  def self.grid   
    # Return Nil if Position is Nil
    return nil if @pos.nil?
   
    # Get X & Y Locations 
    x = (@pos[0] + $game_map.display_x / 4) / 32
    y = (@pos[1] + $game_map.display_y / 4) / 32
   
    # Vehicle Stuff
    $mouse_x = x
    $mouse_y = y
   
    # Return X & Y
    return [x, y]
   
  end
  #--------------------------------------------------------------------------
  # * Mouse Position
  #--------------------------------------------------------------------------
  def self.position
    return @pos == nil ? [0, 0] : @pos
  end
  #--------------------------------------------------------------------------
  # * Mouse Global Position
  #--------------------------------------------------------------------------
  def self.global_pos
    # Packs 0 Position
    pos = [0, 0].pack('ll')
    # Returns Unpacked Cursor Position Call
    return Cursor_Pos.call(pos) == 0 ? nil : pos.unpack('ll')
  end
 
  #--------------------------------------------------------------------------
  # * Screen to Client
  #--------------------------------------------------------------------------
  def self.screen_to_client(x=0, y=0)
    pos = [x, y].pack('ll')
    return Scr2cli.call(self.hwnd, pos) == 0 ? nil : pos.unpack('ll')
  end 
   
  #--------------------------------------------------------------------------
  # * Mouse Position
  #--------------------------------------------------------------------------
  def self.pos

    global_pos = [0, 0].pack('ll')   
    gx, gy = Cursor_Pos.call(global_pos) == 0 ? nil : global_pos.unpack('ll')

    local_pos = [gx, gy].pack('ll')
    x, y = Scr2cli.call(self.hwnd, local_pos) == 0 ? nil : local_pos.unpack('ll')
   
    # Begins Test
    begin
      # Return X & Y or Nil Depending on Mouse Position
      if (x >= 0 && y >= 0 && x <= 640 && y <= 480)
        return x, y
      else
        return -20, -20
      end
    rescue
      return 0, 0 #nil
    end
   
  end 
   
  #--------------------------------------------------------------------------
  # * Update Mouse Position
  #--------------------------------------------------------------------------
  def self.update
   
    # Update Position
    old_pos = @pos
    @pos = self.pos
   
    # agf = hide system mouse
    if !$mouse_sprite.visible && old_pos != @pos
      $mouse_sprite.visible = true
    end
   
    # when mouse leaves game window, show system mouse
    if old_pos != [-20, -20] && @pos == [-20, -20]
      $ShowCursor.call(1)
    # when mouse is in game window, show custom mouse if it's turned on
    elsif old_pos == [-20, -20] && @pos != [-20, -20]
      $ShowCursor.call($game_mouse ? 0 : 1)
    end

    # Update Triggers
    for i in @triggers
      # Gets Async State
      n = GAKS.call(i[1])
      # If 0 or 1
      if [0, 1].include?(n)
        i[0] = (i[0] > 0 ? i[0] * -1 : 0)
      else
        i[0] = (i[0] > 0 ? i[0] + 1 : 1)
      end
    end
   
  end
  #--------------------------------------------------------------------------
  # * Trigger?
  #    id : 0:Left, 1:Right, 2:Center
  #--------------------------------------------------------------------------
  def self.trigger?(id = 0)
   
    #only user trigger if in range of screen
    pos = self.pos
    if pos != [-20,-20]
   
    case id
      when 0  # Left
        return @triggers[id][0] == 1
      when 1  # Right (only when menu enabled)
        if @triggers[1][0] == 1 && !$game_system.menu_disabled
          return @triggers[id][0] == 1     
        end
      when 2  # Center
        return @triggers[id][0] == 1
    end   
   
    end
   
  end
  #--------------------------------------------------------------------------
  # * Repeat?
  #    id : 0:Left, 1:Right, 2:Center
  #--------------------------------------------------------------------------
  def self.repeat?(id = 0)
    if @triggers[id][0] <= 0
      return false
    else
      return @triggers[id][0] % 5 == 1 && @triggers[id][0] % 5 != 2
    end
  end
  #--------------------------------------------------------------------------
  # * Screen to Client
  #--------------------------------------------------------------------------
  def self.screen_to_client(x=0, y=0)
    # Pack X & Y
    pos = [x, y].pack('ll')
    # Return Unpacked Position or Nil
    return Scr2cli.call(self.hwnd, pos) == 0 ? nil : pos.unpack('ll')
  end
  #--------------------------------------------------------------------------
  # * Hwnd - window handle
  #--------------------------------------------------------------------------
  def self.hwnd
    if @hwnd.nil?
      # Finds Game Name from ini file
      game_name = "\0" * 256
      Readini.call('Game', 'Title', '', game_name, 255, ".\\Game.ini")
      game_name.delete!("\0")
      # Finds Window
      @hwnd = Findwindow.call('RGSS Player', game_name)
    end
    return @hwnd
  end
  #--------------------------------------------------------------------------
  # * Client Size
  #--------------------------------------------------------------------------
  def self.client_size
    # Packs Empty Rect
    rect = [0, 0, 0, 0].pack('l4')
    # Gets Game Window Rect
    Client_rect.call(self.hwnd, rect)
    # Unpacks Right & Bottom
    right, bottom = rect.unpack('l4')[2..3]
    # Returns Right & Bottom
    return right, bottom
  end
end

#==============================================================================
# ** Input
#==============================================================================

class << Input
  #------------------------------------------------------------------------
  # * Alias Listings
  #------------------------------------------------------------------------
  unless self.method_defined?(:seph_mouse_input_update)
    alias_method :seph_mouse_input_update,  :update
    alias_method :seph_mouse_input_trigger?, :trigger?
    alias_method :seph_mouse_input_repeat?,  :repeat?
  end
  #------------------------------------------------------------------------
  # * Frame Update
  #------------------------------------------------------------------------
  def update
    # Update Mouse
    Mouse.update
    # Original Update
    seph_mouse_input_update
  end
  #--------------------------------------------------------------------------
  # * Trigger? Test
  #--------------------------------------------------------------------------
  def trigger?(constant)
    # Return true if original test is true
    return true if seph_mouse_input_trigger?(constant)
    # If Mouse Position isn't Nil
    unless Mouse.pos.nil?
      # If Mouse Trigger to Input Trigger Has Constant
      if Mouse::Mouse_to_Input_Triggers.has_value?(constant)
        # Return True if Mouse Triggered
        mouse_trigger = Mouse::Mouse_to_Input_Triggers.index(constant)
        return true if Mouse.trigger?(mouse_trigger)     
      end
    end
    # Return False
    return false
  end
  #--------------------------------------------------------------------------
  # * Repeat? Test
  #--------------------------------------------------------------------------
  def repeat?(constant)
    # Return true if original test is true
    return true if seph_mouse_input_repeat?(constant)
    # If Mouse Position isn't Nil
    unless Mouse.pos.nil?
      # If Mouse Trigger to Input Trigger Has Constant
      if Mouse::Mouse_to_Input_Triggers.has_value?(constant)
        # Return True if Mouse Triggered
        mouse_trigger = Mouse::Mouse_to_Input_Triggers.index(constant)   
        return true if Mouse.repeat?(mouse_trigger)
      end
    end
    # Return False
    return false
  end
end


#==============================================================================
#  ¦ Path Finding
#==============================================================================
# Near Fantastica
# Version 1
# 29.11.05
#==============================================================================

  class Game_Character
    #--------------------------------------------------------------------------
    alias nf_pf_game_character_initialize initialize
    alias nf_pf_game_character_update update
    #--------------------------------------------------------------------------
    attr_accessor :map
    attr_accessor :runpath
    attr_accessor :ovrdest
    #--------------------------------------------------------------------------
    def initialize
      nf_pf_game_character_initialize
      @map = nil
      @runpath = false
      @ovrdest = false
    end
    #--------------------------------------------------------------------------
    def update
      run_path if @runpath == true
      nf_pf_game_character_update
    end
    #--------------------------------------------------------------------------
    def run_path
      return if moving?
      step = @map[@x,@y]
      if step == 1
        @map = nil
        @runpath = false
        return
      end
     
      dir = rand(2)
      case dir
      when 0
        move_right if @map[@x+1,@y] == step - 1 and step != 0
        move_down if @map[@x,@y+1] == step - 1 and step != 0
        move_left if @map[@x-1,@y] == step -1 and step != 0
        move_up if @map[@x,@y-1] == step - 1 and step != 0
      when 1
        move_up if @map[@x,@y-1] == step - 1 and step != 0
        move_left if @map[@x-1,@y] == step -1 and step != 0
        move_down if @map[@x,@y+1] == step - 1 and step != 0
        move_right if @map[@x+1,@y] == step - 1 and step != 0
      end
    end
    #--------------------------------------------------------------------------
    def find_path(x,y, force = true)
      sx, sy = @x, @y
      result = setup_map(sx,sy,x,y)     
      @runpath = result[0]
      @map = result[1]
      @map[sx,sy] = result[2] if result[2] != nil
      $game_player.ignore_movement = @runpath ? force : false
    end
    #--------------------------------------------------------------------------
    def clear_path
      @map = nil
      @runpath = false
      @ovrdest = false
      $game_player.ignore_movement = false
    end
    #--------------------------------------------------------------------------
    def setup_map(sx,sy,ex,ey)
      map = Table.new($game_map.width, $game_map.height)

      # Shaz - adding this comment to the second line of the event commands
      #    Mouse[0,1]
      # will cause the player to go to the tile BELOW the event, turn up,
      # and interact with the event ([0,1] is x+0, y+1)
      tx = ex
      ty = ey
      event = $game_map.event_at(ex, ey)
      if !event.nil? && !event.list.nil? && !event.erased &&
        event.list.size > 1 && event.list[1].code == 108
        text = event.list[1].parameters.to_s
        text.gsub!(/[Mm][Oo][Uu][Ss][Ee]\[([-,0-9]+),([-,0-9]+)\]/) do
          tx = ex + $1.to_i
          ty = ey + $2.to_i
          map[ex, ey] = 999
          @ovrdest = true
        end
      end
     
      update_counter = 0
      map[tx,ty] = 1
      old_positions = []
      new_positions = []
      old_positions.push([tx, ty])
      depth = 2
      $path_allow = false
      depth.upto(100){|step|
        loop do
          break if old_positions[0] == nil
          x,y = old_positions.shift
          return [true, map, step-1] if x == sx and y == sy
          if map[x,y + 1] == 0 and $game_player.passable?(x, y, 2, step, tx, ty)
            map[x,y + 1] = step
            new_positions.push([x,y + 1])
          end
          if map[x - 1,y] == 0 and $game_player.passable?(x, y, 4, step, tx, ty)
            map[x - 1,y] = step
            new_positions.push([x - 1,y])
          end
          if map[x + 1,y] == 0 and $game_player.passable?(x, y, 6, step, tx, ty)
            map[x + 1,y] = step
            new_positions.push([x + 1,y])
          end
          if map[x,y - 1] == 0 and $game_player.passable?(x, y, 8, step, tx, ty)
            map[x,y - 1] = step
            new_positions.push([x,y - 1])
          end
         
          # If we've checked quite a few tiles, allow graphics and input
          # to update - to avoid the 'script hanging' error
          update_counter += 1
          if update_counter > 100
            Graphics.update
            update_counter = 0
          end
        end
       
        old_positions = new_positions
        new_positions = []
      }
     
      @ovrdest = false
      return [false, nil, nil]       
       
    end
  end
 
  class Game_Map
    #--------------------------------------------------------------------------
    alias pf_game_map_setup setup
    #--------------------------------------------------------------------------
    def setup(map_id)
      pf_game_map_setup(map_id)
      $game_player.clear_path
    end
  end
 
  class Game_Player
    #--------------------------------------------------------------------------
    alias pf_game_player_update update
    #--------------------------------------------------------------------------
    def update
      $game_player.clear_path if Input.dir4 != 0
      pf_game_player_update
    end
  end
 
  class Interpreter
    #--------------------------------------------------------------------------
    def event
      return $game_map.events[@event_id]
    end
  end


Código:
#==============================================================================
# ** MouseCursor
#==============================================================================

module MouseCursor
    Default_Cursor = 'Arrow'
    Event_Cursor  = 'Arrow3'
    Actor_Cursor  = 'Arrow'
    Enemy_Cursor  = 'Arrow4'
    Item_Cursor    = true
    Skill_Cursor  = true
    Dummy = Bitmap.new(32, 32)
end

#==============================================================================
# ** Sprite_Mouse
#==============================================================================

class Sprite_Mouse < Sprite
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super
    self.z = 10100
    self.ox = 4
    update
  end
  #--------------------------------------------------------------------------
  # ** Frame Update
  #--------------------------------------------------------------------------
  def update
    super
   
    # Update Visibility
    self.visible = $scene != nil
   
    # If Visible
    if self.visible
     
      # If Non-nil Mouse Position
      if Mouse.position != nil
       
        # Gets Mouse Position
        mx, my = *Mouse.position
       
        # Update POsition
        self.x = mx unless mx.nil?
        self.y = my unless my.nil?     
       
      end
     
      # If Scene changes or Mouse is Triggered
      if @scene != $scene.class || Mouse.trigger?
       
        # Update Scene Instance
        @scene = $scene.class
       
        # Update Bitmap
        set_bitmap(MouseCursor::Default_Cursor)
      end
     
    end
   
  end
  #--------------------------------------------------------------------------
  # ** Set Bitmap
  #--------------------------------------------------------------------------
  def set_bitmap(cursor, xNPCname = nil)
   
    # show fancy cursor only if custom mouse on
    if $game_mouse
           
      # If Cursor Info matches
      if (@_cursor == cursor) && (@_NPCname == xNPCname)
        return
      end
     
      # Reset Cursor Info
      @_cursor      = cursor
      @_NPCname    = xNPCname
     
      # Gets Dummy
      dummy = MouseCursor::Dummy
     
      # Gets Item Cursor Bitmap
      item_cursor = cursor.nil? ? MouseCursor::Default_Cursor : cursor
     
      # Start Cursor Bitmap
      bitmap = RPG::Cache.icon(item_cursor) if item_cursor != ''

      # Show NPC name
      if @_NPCname != nil
        # Get name width
        w = dummy.text_size(@_NPCname).width
        h = dummy.font.size
        b = RPG::Cache.icon(item_cursor)
        # Create New Bitmap
        bitmap = Bitmap.new((bitmap.nil? ? w : 40 + w), [b.height, h + 2].max)
        bitmap.font.size = dummy.font.size
        bitmap.blt(0, 0, b, b.rect)
        # Draw NPC Name
        x = item_cursor == '' ? 0 : 32
        bitmap.font.color = Color.new(0, 0, 0, 255) # black
        bitmap.draw_text(b.width + 9, 0, w, h, @_NPCname) # 0
        bitmap.draw_text(b.width + 11, 0, w, h, @_NPCname) # 0
        bitmap.draw_text(b.width + 10, -1, w, h, @_NPCname) # -1
        bitmap.draw_text(b.width + 10, 1, w, h, @_NPCname) # 1
        bitmap.font.color = Color.new(255, 255, 255, 255) # white
        bitmap.draw_text(b.width + 10, 0, w, h, @_NPCname)
      end   

      # Set Bitmap
      self.bitmap = bitmap
     
    elsif self.bitmap
      @_cursor = nil
      self.bitmap = nil
     
    end
   
  end
  #--------------------------------------------------------------------------
  # ** Frame Update : Update Event Cursors
  #--------------------------------------------------------------------------
  def update_event_cursors
   
    # If Nil Grid Position
    if Mouse.grid.nil?
      # Set Default Cursor
      set_bitmap(MouseCursor::Default_Cursor)
      return
    end
   
    # Gets Mouse Position
    x, y = *Mouse.grid
   
    # Gets Mouse Position
    mx, my = *Mouse.position   
   
    # Gets Mouse Event
    event = $game_map.event_at(x, y)
   
    # If Non-Nil Event or not over map HUD
    unless event.nil?
      # If Not Erased or Nil List
      if event.list != nil && event.erased == false && event.list[0].code == 108
        # Get the cursor to show
        icon = event.list[0].parameters
        icon = icon.to_s
        if !((icon == "Arrow2") ||
          (icon == "Arrow3") ||
          (icon == "Arrow4") ||
          (icon == "Arrow5") ||
          (icon == "Arrow6") ||
          (icon == "Arrow7"))
          icon = MouseCursor::Default_Cursor
        end       
        xNPCname = nil
        if event.list.size > 1 && event.list[1].code == 108
          text = event.list[1].parameters.to_s
          text.gsub!(/[Nn][Aa][Mm][Ee] (.*)/) do
            xNPCname = $1.to_s
          end
        end
        set_bitmap(icon, xNPCname)   
        return
      end
      return
    end
   
    # Set Default Cursor
    set_bitmap(MouseCursor::Default_Cursor)
   
  end
end

#==============================================================================
# ** Input
#==============================================================================

class << Input
  #------------------------------------------------------------------------
  # * Alias Listings
  #------------------------------------------------------------------------
  unless self.method_defined?(:sephlamchop_mousesys_input_update)
    alias_method :sephlamchop_mousesys_input_update,  :update
  end
  #------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    $mouse_sprite.update if $mouse_sprite.visible
    # Original Update
    sephlamchop_mousesys_input_update
  end
end




Código:
WORLD_MAP_ID = 1

#==============================================================================
# ** Game_Map
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Event At
  #--------------------------------------------------------------------------
  def event_at(x, y)
    for event in @events.values
        return event if event.x == x && event.y == y
    end
    return nil
  end
 
  #--------------------------------------------------------------------------
  # * Events At (returns multiple events at the same position in an array)
  #--------------------------------------------------------------------------
  def events_at(x, y)
    eventarray = []
    for event in @events.values
      eventarray.push event if event.x == x && event.y == y
    end
    return eventarray if eventarray.size > 0
    return nil
  end

end

#==============================================================================
# ** Game_Event
#==============================================================================

class Game_Event
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader  :erased                  # trigger
  attr_accessor :mouse_autostart        # mouse autostart boolean
  attr_accessor :mouse_cursor_icon      # mouse cursor icon
  attr_accessor :mouse_cursor_desc      # mouse cursor desc
  attr_reader  :name                    # name of event
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :sephlamchop_mousesys_gmevt_refresh, :refresh
  #--------------------------------------------------------------------------
  # * Start Event
  #--------------------------------------------------------------------------
  def start
    # If list of event commands is not empty
    if @list && @list.size > 1
      @starting = true
    end
  end 

  #--------------------------------------------------------------------------
  # * Refresh
  #-------------------------------------------------------------------------- 
  def refresh
    # Original Refresh
    sephlamchop_mousesys_gmevt_refresh
    # Click triggers event for action button, player or event touch
    @mouse_autostart  = [0, 1, 2].include?(@trigger)
    @mouse_cursor_icon = MouseCursor::Event_Cursor
    @mouse_cursor_desc = nil
    # Return if Erased or Nil List
    #return if @erased || @list.nil?
   
  end
end

#==============================================================================
# ** Game_Character
#==============================================================================
class Game_Character
 
  def passable?(x, y, d, step = 999, tx = nil, ty = nil)
   
    # Get new coordinates
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
   
    # If coordinates are outside of map
    unless $game_map.valid?(new_x, new_y)
      return false
    end
   
    # If through is ON
    if @through
      return true
    end
   
    # Able to leave current tile in desired direction?
    # SHAZ: for counter, must be old, counter, new, in a straight line
    unless $game_map.passable?(x, y, d, self) || (step == 2 && $game_map.event_at(x, y)) ||
      (step == 3 && $game_map.counter?(x, y) && tx != nil && ty != nil &&
      new_x - x == x - tx && new_y - y == y - ty)
      return false
    end
   
    # Able to enter adjoining tile in current direction?
    unless $game_map.passable?(new_x, new_y, 10 - d) ||
      (step == 2 && $game_map.counter?(new_x, new_y))
      return false
    end

    # SHAZ - ignore events sitting on a counter next to the destination
    if step != 2 || !$game_map.counter?(new_x, new_y)         
      # Loop all events
      for event in $game_map.events.values
        # If event coordinates are consistent with move destination
        if event.x == new_x and event.y == new_y
          @state = true
          # If through is OFF
          unless event.through
            # If self is event
            if self != $game_player
              return false
            end
            # With self as the player and partner graphic as character
            if event.character_name != ""
              return false
            end
          end
        end
      end
    end
   
    # If on world map, don't allow to go through events.  Otherwise,
    # the event will be triggered while the PC is walking
    if $game_map.map_id == WORLD_MAP_ID && @state == false
      return false
    end     

    # If player coordinates are consistent with move destination
    if $game_player.x == new_x && $game_player.y == new_y && self != $game_player
      # If through is OFF
      unless $game_player.through
        # If your own graphic is the character
        if @character_name != ""
          return false
        end
      end
    end

    return true
   
  end
end

#==============================================================================
# ** Game_Player
#==============================================================================

class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :sephlamchop_mousesys_gmplyr_update, :update
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Unless Interpreter Running, Forcing a Route or Message Showing
    unless $game_system.map_interpreter.running? or
          @move_route_forcing or $game_temp.message_window_showing
         
      # Find Path If Mouse Triggered
      if Mouse.trigger?(0) && Mouse.grid != nil

        # Check if mouse is over HUD on map
        screen_x,screen_y = Mouse.pos
       
        # Gets Mouse X & Y
        mx, my = *Mouse.grid
       
        # Turn Character in direction
        newd_x = (@x - mx).abs
        newd_y = (@y - my).abs
       
        if @x > mx
            turn_left if newd_x >= newd_y
        elsif @x < mx
            turn_right if newd_x >= newd_y
        end 
           
        if @y > my
            turn_up if newd_x < newd_y
        elsif @y < my
            turn_down if newd_x < newd_y
        end

        # Run Pathfinding
        find_path(mx, my, false)
       
        # Gets Event
        @eventarray = @runpath ? $game_map.events_at(mx, my) : nil
        # If Event At Grid Location
        unless @eventarray.nil?
          @eventarray.each do |event|
            # If Event Autostart
            if !event.mouse_autostart
              @eventarray.delete(event)
            end
          end
          @eventarray = nil if @eventarray.size == 0
        end
       
      end
    end
   
    if @move_route_forcing
      clear_path
      @eventarray = nil
    end
   
    # Original Update
    sephlamchop_mousesys_gmplyr_update
    # If Non-nil Event Autostarter
    if @eventarray != nil && !moving? &&
      (!@ovrdest || @map.nil? || @map[@x,@y] == 1)
      # Gets Event
      @eventarray.each do |event|
     
        # If Event Within Range
        if event and (@x == event.x or @y == event.y)
          # SHAZ - trigger event when:
          # - Action button and standing on or beside, or with a counter between
          # - player/event touch and standing as close as possible (on, if possible)
          distance = Math.hypot(@x - event.x, @y - event.y)
          dir = @x < event.x ? 6 : @x > event.x ? 4 : @y < event.y ? 2 : @y > event.y ? 8 : 0
          if (event.trigger == 0 and (distance < 2 or (distance == 2 and
            $game_map.counter?((@x+event.x)/2, (@y+event.y)/2)))) or
            ([1,2].include?(event.trigger) and ((distance == 0 and
            $game_player.passable?(@x, @y, dir)) or (distance == 1 and
            !$game_player.passable?(@x, @y, dir))))
            # Turn toward Event
            if @x == event.x
              turn_up if @y > event.y
              turn_down if @y < event.y
            else
              turn_left if @x > event.x
              turn_right if @x < event.x
            end
            # Start Event
            clear_path
            event.start
            @eventarray.delete(event)
            @eventarray = nil if @eventarray.size == 0
          end
        end
     
      end     
    end

  end
 
  def passable?(x1, y1, d, step = 999, tx = nil, ty = nil)
    super
  end
 
end

#==============================================================================
# ** Mouse Selectable Windows
#------------------------------------------------------------------------------
# SephirothSpawn
# Version 2.1
#==============================================================================
#==============================================================================
# ** Window_Base
#==============================================================================

class Window_Base
  #--------------------------------------------------------------------------
  # * Frame Update : Mouse Cursor - Item
  #--------------------------------------------------------------------------
  def update_mouse_cursors_item(item, cursor, show)
    # Return if not Active
    return unless self.active
    # Return if nil Position
    return if Mouse.position.nil?
    # Gets Mouse Position
    mx, my = Mouse.position
    # Gets Cursor Position
    cr = self.cursor_rect
    cx, cy = cr.x + self.x + 16, cr.y + self.y + 16
    cw, ch = cr.width, cr.height
    # If Not on Item
    if mx.between?(self.x, self.x + self.width) == false ||
      my.between?(self.y, self.y + self.height) == false || item.nil? ||
      @item_max == 0 || mx.between?(cx, cx + cw) == false ||
      my.between?(cy, cy + ch) == false
      # Clear Mouse Index
      @mouse_index = nil
      # Set Mouse to Default Cursor
      $mouse_sprite.set_bitmap(MouseCursor::Default_Cursor)
      return
    end
    # If Index is different than mouse index and window active
    if @mouse_index != @index
      # Reset Index
      @mouse_index = @index
      # set to item icon if cursor is true
      cursor = item.icon_name if cursor
      # Set Bitmap
      $mouse_sprite.set_bitmap(cursor)
    end
  end
 
end

class Window_Selectable
  #--------------------------------------------------------------------------
  # * Default Settings
  #--------------------------------------------------------------------------
  Default_Mouse_Selectable = true
  Default_Window_Padding  = 16
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :mouse_selectable
  attr_accessor :window_padding
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :seph_mouseselectable_wndslct_init,  :initialize
  alias_method :seph_mouseselectable_wndslct_update, :update
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    # Original Initialization
    seph_mouseselectable_wndslct_init(x, y, width, height)
    # Set Mouse Selectable Flag
    @mouse_selectable = Default_Mouse_Selectable
    @window_padding  = Default_Window_Padding
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
   
    # agf = hide mouse
    if $mouse_sprite.visible == true
   
    # If Mouse Selectable, Active, at Least 1 Item and Non-negitive index
    if self.mouse_selectable && self.active && @item_max > 0 && @index >= 0
      # Gets Mouse Position
      mouse_x, mouse_y = *Mouse.position
     
      # If Mouse Within Window     
      if mouse_x.between? (self.x, self.x + self.width) &&
        mouse_y.between? (self.y, self.y + self.height)
        # Calculates Mouse X and Y Position Within Window
        mouse_x -= self.x ; mouse_y -= self.y
        # Subtracts Window Padding
        mouse_x -= @window_padding ; mouse_y -= @window_padding
        # Subtracts Mouse Oh
        mouse_y -= self.mouse_oh
        # Gets Cursor Width
        cursor_width = (self.width / @column_max - 32)
        # Passes Through Item Max
        for i in 0...@item_max
          # Calculates Index Position
          x = i % @column_max * (cursor_width + 32)
          y = i / @column_max * self.oh - self.oy
          # If Mouse Between Rect
          if mouse_x.between?(x, x + cursor_width) &&
            mouse_y.between?(y, y + self.oh)
            # Set Index
            prev_index = @index
            @index = i
            if prev_index != @index
              $game_system.se_play($data_system.cursor_se)
            end
            break
          end
        end
      end
    end
   
    end
   
    # Original Update
    seph_mouseselectable_wndslct_update
  end
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 32
  end
  #--------------------------------------------------------------------------
  # * Mouse Oh
  #--------------------------------------------------------------------------
  def mouse_oh
    return 0
  end 
 
end


#==============================================================================
# ** Window_MenuStatus
#==============================================================================

class Window_MenuStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 60
  end
end

#==============================================================================
# ** Window_Target
#==============================================================================

class Window_Target < Window_Selectable
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 105
  end
end

#==============================================================================
# ** Window_BattleReserve
#==============================================================================

class Window_BattleReserve < Window_Selectable
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 105
  end
end

#==============================================================================
# ** Window_EquipRight
#==============================================================================

class Window_EquipRight < Window_Selectable
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 50
  end
 
  #--------------------------------------------------------------------------
  # * Mouse Oh
  #--------------------------------------------------------------------------
  def mouse_oh
    return 140
  end 
 
end

#==============================================================================
# ** Window_Message
#==============================================================================

class Window_Message < Window_Selectable
  #--------------------------------------------------------------------------
  # * Mouse Oh
  #--------------------------------------------------------------------------
  def mouse_oh
    return $game_temp.choice_start * 32
  end
end

#==============================================================================
# ** Window_Party
#==============================================================================

class Window_Party < Window_Selectable
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 52
  end
end


#==============================================================================
# ** Window_Menu
#==============================================================================

class Window_Menu < Window_Selectable
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 35
  end
end

#==============================================================================
# ** Window_ActorCommand
#==============================================================================

class Window_ActorCommand < Window_Selectable
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    if $mouse_sprite.visible
     
      # if Mouse sleectable, active, at least 1 item and non-negative index
      if self.mouse_selectable && self.active && @item_max > 0 && @index >= 0
        # Get / check mouse position
        mouse_x, mouse_y = *Mouse.position
       
        if mouse_x.between?(self.x, self.x + self.width) &&
          mouse_y.between?(self.y, self.y + self.height)
         
          # Calculates mouse position within window
          mouse_x -= self.x
          mouse_y -= self.y
         
          # Subtracts widnow padding and overhead
          mouse_x -= @window_padding
          mouse_y -= @window_padding - self.mouse_oh
         
          # Look through all items
          for i in 0...@item_max
            ix,iy = @positions[i]
            if mouse_x.between?(ix, ix + 32) && mouse_y.between?(iy, iy + self.oh)
              if i != @index
                $game_system.se_play($data_system.cursor_se)
              end
              @index = i
              break
            end
          end
        end
      end
    end
   
    super
  end
 
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
  def oh
    return 32 
  end
end


#==============================================================================
# ** Window_NameInput
#==============================================================================

class Window_NameInput < Window_Base
  #--------------------------------------------------------------------------
  # * Default Settings
  #--------------------------------------------------------------------------
  Default_Mouse_Selectable = true
  Default_Window_Padding = 16
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :mouse_selectable
  attr_accessor :window_padding
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :shaz_mouseselectable_wndslct_init,  :initialize
  alias_method :shaz_mouseselectable_wndslct_update, :update
  #--------------------------------------------------------------------------
  # ● Initialize the Name Input window
  #--------------------------------------------------------------------------
  def initialize
    # Original Initialization
    shaz_mouseselectable_wndslct_init
    # Set Mouse Selectable Flag
    @mouse_selectable = Default_Mouse_Selectable
    @window_padding = Default_Window_Padding
  end

  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------

  def update
   
    # if mouse selectable, visible, active, and non-negative index
    if $mouse_sprite.visible && self.mouse_selectable && self.active &&
      @index >= 0
     
      # Get mouse position
      mouse_x, mouse_y = *Mouse.position
     
      # If mouse within window
      if mouse_x.between? (self.x, self.x + self.width) &&
        mouse_y.between? (self.y, self.y + self.height)
       
        # Calculates mouse X and Y positions within window
        mouse_x -= self.x ; mouse_y -= self.y
       
        # Subtracts window padding
        mouse_x -= @window_padding ; mouse_y -= @window_padding
       
        # Subtracts mouse oh
        mouse_y -= self.mouse_oh
       
        # Gets cursor width
        cursor_width = 28
       
        # If not Submit button, pass through all items
        if mouse_x.between?(428, 428+48) && mouse_y.between?(9*32, 9*32+32)
          $game_system.se_play($data_system.cursor_se) if @index != 180
          @index = 180
        else
          for i in 0..90 
           
            # Calculate index position
            x = 140 + i / 5 / 9 * 180 + i % 5 * 32
            y = i / 5 % 9 * 32
           
            # If mouse between rect
            if mouse_x.between?(x, x + cursor_width) &&
              mouse_y.between?(y, y + self.oh)
              # set index
              prev_index = @index
              @index = i
              if prev_index != @index
                $game_system.se_play($data_system.cursor_se)
              end
              break
            end
          end
        end
      end
    end
   
    # Original update
    shaz_mouseselectable_wndslct_update
  end
 
  #--------------------------------------------------------------------------
  # * Oh
  #--------------------------------------------------------------------------
 
  def oh
    return 32
  end
 
  #--------------------------------------------------------------------------
  # * Mouse Oh
  #--------------------------------------------------------------------------
 
  def mouse_oh
    return 0
  end
 
end


#==============================================================================
# ** Scene_File
#==============================================================================

class Scene_File
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :sephlamchop_mousesys_scnfl_update, :update
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
   
    # agf = hide mouse
    if $mouse_sprite.visible == true   
   
    # If Mouse Position isn't Nil
    if Mouse.pos != nil
     
      # Gets Mouse Position
      x, y = Mouse.pos
      y = y + 32
     
      # Pass Through Savefile Windows
      for i in 0...@savefile_windows.size
       
        # Gets Window
        w = @savefile_windows[i]
       
        # Don't allow user to select autosave slot in Load Menu
        if @autosave_slot == false
          i = 1 if i == 0
        end
       
        # If Within Window Range
        if x.between?(w.x, w.x + w.width) &&
          y.between?(w.y, w.y + w.height) && w.active
                     
          prev_index = @file_index
         
          # Set File Index
          @file_index = i
         
          # Turns Window On
          w.selected = true
         
          # Play SE
          if prev_index != @file_index
            $game_system.se_play($data_system.cursor_se)
          end         
         
          # Unhighlight remaining windows
          for j in 0...@savefile_windows.size
            if j != i
              @savefile_windows[j].selected = false
            end
          end       

          # Don't select autosave slot in Load Menu
          if @autosave_slot == false
            @savefile_windows[0].selected = false if i == 1
          end
         
          # Break Main Loop
          break           
        end
      end
    end
 
    end
 
    # Original Update
    sephlamchop_mousesys_scnfl_update
  end
end


#==============================================================================
# ** Game_Battler
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # * Battler Width
  #--------------------------------------------------------------------------
  def battler_width
    return RPG::Cache.battler(@battler_name, @battler_hue).width
  end
  #--------------------------------------------------------------------------
  # * Battler Height
  #--------------------------------------------------------------------------
  def battler_height
    return RPG::Cache.battler(@battler_name, @battler_hue).height
  end
end

#==============================================================================
# ** Arrow_Enemy
#==============================================================================

class Arrow_Enemy < Arrow_Base
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :seph_mouseselectablewindows_arrenmy_update, :update
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Original Update
    seph_mouseselectablewindows_arrenmy_update
   
    if $mouse_sprite.visible == true
      # Return if Nil Mouse Position
      return if Mouse.position.nil?
      # Gets Mouse Position
      mx, my = *Mouse.position
      # Pass Through Enemies
      $game_troop.enemies.each do |enemy|
        # Skip if Non-Existing Enemy
        next unless enemy.exist?
        # Gets Paddings
        w, h = enemy.battler_width / 2, enemy.battler_height
        # If Within Mouse Padding Range
        if mx.between?(enemy.screen_x - w, enemy.screen_x + w) &&
          my.between?(enemy.screen_y - h, enemy.screen_y + 10)
          # Set Index
          @index = $game_troop.enemies.index(enemy)
          # Set mouse cursor to bitmap
          $mouse_sprite.set_bitmap(MouseCursor::Enemy_Cursor)
          return
          # break
        end
      end
   
      # Set Mouse to Default Cursor
      $mouse_sprite.set_bitmap(MouseCursor::Default_Cursor)
    end
   
  end
end

#==============================================================================
# ** Arrow_Actor
#==============================================================================

class Arrow_Actor < Arrow_Base
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :seph_mouseselectablewindows_arractr_update, :update
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Original Update
    seph_mouseselectablewindows_arractr_update
    # Return if Nil Mouse Position
    return if Mouse.position.nil?
    # Gets Mouse Position
    mx, my = *Mouse.position
    # Pass Through Actors
    $game_party.actors.each do |actor|
      # Gets Paddings
      w, h = actor.battler_width / 2, actor.battler_height
      # If Within Mouse Padding Range
      if mx.between?(actor.screen_x - w, actor.screen_x + w) &&
        my.between?(actor.screen_y - h, actor.screen_y + 10)
        # Set Index
        @index = $game_party.actors.index(actor)
      end
    end
  end
end

#==============================================================================
# ** Scene_Map
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :sephlamchop_mousesys_scnmap_update, :update
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Unless Message Showing
    unless $game_temp.message_text
      # Update Event Cursors
      $mouse_sprite.update_event_cursors
    end
    # Original Update
    sephlamchop_mousesys_scnmap_update
  end
end

#==============================================================================
# ** Interpreter
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :shaz_mousesys_intrprtr_command_101, :command_101
  #--------------------------------------------------------------------------
  # * Show Text
  #--------------------------------------------------------------------------
  def command_101
    # return mouse sprite to default cursor
    $mouse_sprite.set_bitmap(MouseCursor::Default_Cursor)
    # original command_101
    shaz_mousesys_intrprtr_command_101
  end
end

$mouse_sprite = Sprite_Mouse.new

# game mouse is visible, system mouse is hidden
$mouse_sprite.visible = true


Cada Código va en un script diferente. Tambien se requieren estas imagenes:


Van en la carpeta de Icons.
avatar
MaddManu
Soñador
Soñador

0/3

Créditos 373

Gracias : 4

Volver arriba Ir abajo

RPG Maker XP Re: Script para usar ratón.

Mensaje por incognitogris el 2016-08-09, 14:33

Primero que todo... este es el primer post donde encuentro el script + los iconos, no obsoletos. ¡Gracias! Very Happy

Aunque a mucha gente les salta el siguiente error:
????? 'Mouse 1' ? 334 ??? NoMethodError ???????? undefined methpd 'ignore_movement=' for #

La solución es pegar la siguiente línea:
attr_accessor :ignore_movement
bajo   class Game_Player (línea 416)
A mí, al menos, me funciona con el script de este post gcool
avatar
incognitogris
Iniciado
Iniciado

0/3

Créditos 4

Gracias : 3

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.