[XP - Script]Erweitertes Mausskript - Basierend auf cybersams Skript

[MagicMagor]

(Formatierungstemplate von rmxp.net)

Mouse script
Version: 1.0

Intro

Das ganze ist nur ein etwas größerer Edit von cybersams Maus-Skript. Es beinhaltet nun ein automatisches Cursor-Skript und es ist nun einfacher die Mauskoordinaten in game-variablen abzulegen. Daneben ist es generell einfacher zu benutzen als das orginalskript, zumindest ist das meine Meinung. Achja und sauberer ist der Code IMO auch =).

Features
[*]Automatisches Cursorskript (kann an und aus-geschaltet werden)
[*]Automatisches Speichern der Mauskoordinaten in game-variablen (kann an und aus-geschaltet werden)

Screenshots

Machen hier nicht wirklich Sinn..

Demo

Demolink: Maus-Script
Danke an Kai für das Hosten der Demo. Das englische RTP (1.02) wird benötigt.

Script

Code:

#==============================================================================
#
# Mouse Script 1.0                                      created by: cybersam
#                                                       edited by: MagicMagor
#
#==============================================================================
#
# (got rid of cybersams explanation here, because it isn't true for this module)
#                                                       MagicMagor
#==============================================================================

#==============================================================================
# I have edited cybersams script, to fit my needs and my personal style of
# coding. I have also extended the script and got rid of several bugs. 
# If you use this, give credit to cybersam and me.
#------------------------------------------------------------------------------
# MagicMagor
#==============================================================================

module Mouse

  MOUSE_LEFT    = 0x01        # left mouse button
  MOUSE_RIGHT   = 0x02        # right mouse button

  attr_reader :MOUSE_LEFT, :MOUSE_RIGHT

  # Flags
  
  INIT_CURSOR = 0x01
  INIT_SAVE = 0x02
  INIT_TYPE = 0x03

  CURSOR_PIC = 0x01
  CURSOR_ROOT = 0x02
  CURSOR_BITMAP = 0x03
  
  attr_reader :INIT_CURSOR, :INIT_SAVE, :INIT_TYPE,
              :CURSOR_PIC, :CURSOR_ROOT, :CURSOR_BITMAP


  @getCursorPos = Win32API.new('user32', 'GetCursorPos', 'p', 'i')
  @getWindowRect = Win32API.new('user32', 'GetWindowRect', ['p', 'p'], 'i')
  @scr2cli = Win32API.new('user32', 'ScreenToClient', %w(l p), 'i')
  @client_rect = Win32API.new('user32', 'GetClientRect', %w(l p), 'i')
  @readini = Win32API.new('kernel32', 'GetPrivateProfileStringA', %w(p p p p l p), 'l')
  @findwindow = Win32API.new('user32', 'FindWindow', %w(p p), 'l')
  @getKeyState = Win32API.new("user32","GetAsyncKeyState",['i'],'i')
    
  #---------------------------------------------------------------------------
  # Initialize the mouse-system, with given arguments. Is automaticly called
  # if needed.
  #---------------------------------------------------------------------------
  def Mouse.initSystem(*args)
    @init = true
    @handle = self.getHandle()
    @cursor = Sprite.new()
    if args.length >= 1
      flags = args[0]
      @showCursor  = (flags & INIT_CURSOR)
      @saveToGame = (flags & INIT_SAVE)
      withType = (flags & INIT_TYPE)
      if (@showCursor != 0)
        @showCursor = true
      else
        @showCursor = false
      end
      if (@saveToGame != 0)
        @saveToGame = true
      else
        @saveToGame = false
      end
      @cursor.visible = @showCursor
      @originX = 0
      @originY = 0
      if (@saveToGame)
        @gameX = args[-2]
        @gameY = args[-1]
      end
      if (@showCursor)
        if (withType)
          self.setCursor(args[1], args[2])
        else
          self.setCursor(args[1])
        end
      end
    end
    return nil
  end
  
  #---------------------------------------------------------------------------
  # Checks if key was pressed.
  #---------------------------------------------------------------------------  
  def Mouse.pressed?(key)
   return ((@getKeyState.call(key) & 0x01) == 1)
  end

  #---------------------------------------------------------------------------
  # Returns true if saving mouse positions to game-variables is enabled
  #---------------------------------------------------------------------------  
  def Mouse.saveToGame?()
    if !(@init)
      self.initSystem(nil)
    end
    return @saveToGame
  end
  
  #---------------------------------------------------------------------------
  # Enables saving the mouse positions to game-variables
  #---------------------------------------------------------------------------  
  def Mouse.enableSaveToGame(game_x = nil, game_y = nil )
    if !(@init)
      self.initSystem(nil)
    end
    @saveToGame = true
    if (game_x != nil)
      @gameX = game_x
    end
    if (game_y != nil)
      @gameY = game_y
    end
    return nil
  end
  
  #---------------------------------------------------------------------------
  # Disables saving the mouse positions to game-variables
  #---------------------------------------------------------------------------  
  def Mouse.disableSaveToGame()
    if !(@init)
      self.initSystem(nil)
    end
    @saveToGame = false
    return nil
  end

  #---------------------------------------------------------------------------
  # Sets the variable-ID in which the X position is saved
  #---------------------------------------------------------------------------  
  def Mouse.setGameX(game_x)
    if !(@init)
      self.initSystem(nil)
    end
    @gameX = game_x
    return nil
  end
  
  #---------------------------------------------------------------------------
  # Sets the variable-ID in which the Y position is saved
  #---------------------------------------------------------------------------  
  def Mouse.setGameY(game_y)
   if !(@init)
      self.initSystem(nil)
    end
   @gameY = game_y
   return nil
  end
  
  #---------------------------------------------------------------------------
  # Returns the variable-ID in which the X position is saved
  #---------------------------------------------------------------------------  
  def Mouse.gameX
    return @gameX
  end  

  #---------------------------------------------------------------------------
  # Returns the variable-ID in which the Y position is saved
  #---------------------------------------------------------------------------  
  def Mouse.gameY
    return @gameY
  end

  #---------------------------------------------------------------------------
  # Returns X-Value of mouse positions
  #---------------------------------------------------------------------------    
  def Mouse.x()
    if !(@init)
      self.initSystem(nil)
    end
    x, y = Mouse.mousePos()
    return x
  end

  #---------------------------------------------------------------------------
  # Returns Y-Value of mouse positions
  #---------------------------------------------------------------------------    
  def Mouse.y()
    if !(@init)
      self.initSystem(nil)
    end
    x, y = Mouse.mousePos()
    return y
  end
    
  #---------------------------------------------------------------------------
  # Returns TRUE when the mouse-cursor is shown.
  #---------------------------------------------------------------------------    
  def Mouse.shown?()
    if !(@init)
      self.initSystem(nil)
    end
    return @showCursor
  end

  #---------------------------------------------------------------------------
  # Enables showing of the mouse-cursor.
  #---------------------------------------------------------------------------    
  def Mouse.enableShow()
    if !(@init)
      self.initSystem(nil)
    end
    @showCursor = true
    @cursor.visible = true
    return nil
  end
    
  #---------------------------------------------------------------------------
  # Disable showing of the mouse-cursor.
  #---------------------------------------------------------------------------    
  def Mouse.disableShow()
    if !(@init)
      self.initSystem(nil)
    end
    @showCursor = false
    @cursor.visible = false
    return nil
  end

  #---------------------------------------------------------------------------
  # Sets a new bitmap for the cursor.
  #---------------------------------------------------------------------------    

  def Mouse.setCursor(filename, type = CURSOR_PIC, originX = 0, originY = 0)
    if !(@init)
      self.initSystem(nil)
    end
    @originX = originX
    @originY = originY
    case type
    when CURSOR_PIC
      @cursor.bitmap = RPG::Cache.picture(filename)
      @cursor.z = 999    
      return nil
    when CURSOR_ROOT
      @cursor.bitmap = Bitmap.new(filename)
      @cursor.z = 999
      return nil
    when CURSOR_BITMAP
      @cursor.bitmap = filename
      @cursor.z = 999
      return nil
    end
  end
  
  #---------------------------------------------------------------------------
  # Sets the x-coordinate of the cursor-picture origin.
  #---------------------------------------------------------------------------    
  def Mouse.setOriginX(originX)
    if !(@init)
      self.initSystem(nil)
    end
    @originX = originX
    return nil
  end
    
  #---------------------------------------------------------------------------
  # Sets the y-coordinate of the cursor-picture origin.
  #---------------------------------------------------------------------------    
  def Mouse.setOriginY(originY)
    if !(@init)
      self.initSystem(nil)
    end
    @originY = originY
    return nil
  end

  #---------------------------------------------------------------------------
  # Updates the position of the mouse-cursor on screen.
  #---------------------------------------------------------------------------    
  def Mouse.update()
    if !(@init)
      self.initSystem(nil)
    end
    if (@showCursor)
      if Mouse.x() != nil
        @cursor.x = Mouse.x() - @originX
      end
      if Mouse.y() != nil
        @cursor.y = Mouse.y() - @originY
      end
    end
    if ((@saveToGame) && (@gameX != nil) && (@gameY != nil))
      $game_variables[@gameX] = Mouse.x()
      $game_variables[@gameY] = Mouse.y()
    end
    return nil
  end
  
#===============================================================================  
# Private methods start here
# Do not call them directly.
# Edit them only if you know what you are doing.
#===============================================================================  
  
  #---------------------------------------------------------------------------
  # Calculates mouse position inside the programms window.
  #---------------------------------------------------------------------------  
  def Mouse.mousePos(catch_anywhere = false)
    x, y = Mouse.screenToClient(*Mouse.getPos)
    width, height = Mouse.clientSize()
    if ((x == nil) || (y == nil))
      return nil
    end
    if ((catch_anywhere) || ((x >= 0) && (y >= 0) && (x < width) && (y < height)))
      return x, y
    else
      return nil
    end
  end
  
  #---------------------------------------------------------------------------
  # Gets mouse position from OS.
  #---------------------------------------------------------------------------  
  def Mouse.getPos()
    if !(@init)
      Mouse.initSystem(nil)
    end
    pos = [0, 0].pack('ll')
    if @getCursorPos.call(pos) != 0
      return pos.unpack('ll')
    else
      return nil
    end
  end
  
  #---------------------------------------------------------------------------
  # Transforms screen-coordinates in client-coordinates.
  #---------------------------------------------------------------------------    
  def Mouse.screenToClient(x, y)
    if !(@init)
      self.initSystem(nil)
    end
    return nil unless x and y
    pos = [x, y].pack('ll')
    if @scr2cli.call(@handle, pos) != 0
      return pos.unpack('ll')
    else
      return nil
    end
  end
  
  #---------------------------------------------------------------------------
  # Gets the client size from OS.
  #---------------------------------------------------------------------------    
  def Mouse.clientSize()
    if !(@init)
      self.initSystem(nil)
    end
    rect = [0, 0, 0, 0].pack('l4')
    @client_rect.call(@handle, rect)
    right, bottom = rect.unpack('l4')[2..3]
    return right, bottom
  end
  
  #---------------------------------------------------------------------------
  # Gets the windows handle from OS.
  #---------------------------------------------------------------------------    
  def Mouse.getHandle()
    if !(@init)
      self.initSystem(nil)
    end
    gameName = "\0" * 256
    @readini.call('Game', 'Title', '', gameName, 255, ".\\Game.ini")
    gameName.delete!("\0")
    if ($DEBUG)
      # Only one RGSS Player should be open
      result = @findwindow.call('RGSS Player', 0) 
    else
      result = @findwindow.call('RGSS Player', gameName)
    end
    return result
  end    

end

Anweisungen

Das ganze Skript wird über "Call Script"-Befehle gesteuert.
Wenn ihr das integrierte Cursor-Skript benutzen wollt, müßt ihr einmal folgendes aufrufen:

Code:

Mouse.setCursor(filename[, type, originX, originY])

type, originX and originY können weggelassen werden. filename ist der Name der Datei die als Cursor-Bild verwendet wird. Sie muss dabei als Picture ins Spiel importiert worden sein. origin ist der Punkt auf dem Sprite, der exakt auf den Mauskoordinaten liegt. Standard ist die linke obere Ecke (0/0). Wenn das Sprite einen anderen Punkt benötigt (ein Fadenkreuz zB.), müßt ihr den origin entsprechend setzen. Entweder direkt über setCursor oder mittels dieser beiden Methoden:

Code:

Mouse.setOriginX(originX) # Sets the x-coordinate of the origin
Mouse.setOriginY(originY) # Sets the y-coordinate of the origin

Der Typ (type) des cursors sagt dem Skript wo es nach dem Cursor-Bild suchen soll. Diese Werte sind möglich:
Mouse:URSOR_PIC
Die Datei ist als Picture importiert und demnach im Picture-Ordner zu finden. filename beinhaltet nur den Dateinamen.
Mouse:URSOR_ROOT
Die Datei ist nicht als Picture importiert sondern liegt woanders. filename beinhaltet den gesamten Pfad zur Datei, wobei "./" den Spieleordner repräsentiert (der wo die exe drin liegt).
Mouse:URSOR_BITMAP
Der Cursor wird nicht aus einer Datei geladen. Stattdessen ist filename bereits ein Bitmap-Objekt, das als Cursor verwendet wird.

--------------------------------

Um die Koordinaten in Game-Variablen abzulegen müsst ihr einmal diese Methode aufrufen:

Code:

Mouse.enableSaveToGame(gameX, gameY)

gameX und gameY sind die IDs der Variablen in denen die Koordinaten ablegt werden. Das Skript prüft nicht ob die angegeben Werte korrekt sind (zwischen 1 und 5000), sind sie es nicht, wird das Skript mit einer Fehlermeldung abbrechen. Wenn gameX und gameY bereits mit sinnvollen Werten gefüllt sind, können diese Werte bei dieser Methode auch weggelassen werden.

Wenn ihr das Cursor-Skript oder das Abspeichern der Koordinaten in Game-Variablen benutzt müßt ihr "Mouse.update()" jeden Frame aufrufen. Es reicht den Aufruf in ein PP zu packen.

Um Platz zu sparen kann man einige oder alle Features des Skript durch korrekte Initilaisierung des Skriptes anschalten:

Code:

Mouse.initSystem(flags[additonial arguments])
# The first arguments are the flags, telling the script which features to activate
# Mouse::INIT_CURSOR
# Activates the cursor. The next argument of initSystem is the same as "filename" in setCursor.
# Uses CURSOR_PIC as cursor-type, unless specified
# Mouse::INIT_TYPE
# Specifies which cursor-type (see setCursor) is used. The third argument of initSystem is now the cursor-type
# Mouse::INIT_SAVE
# Activates saving the coordinates to game-variables. The last two arguments of initSystem are gameX and gameY
# Flags are combined with '|', see the demo for an example.

(Zu faul zum übersetzen atm)

Um zu überprüfen ob eine Maustaste gedrückt wurde könnt ihr folgendes verwenden (Conditional Branch Seite4 Script):

Code:

Mouse.pressed?(key)

key hat zwei gültige Werte, Mouse::MOUSE_LEFT und Mouse::MOUSE_RIGHT, für die linke und die rechte Maustaste.

Für weitere Methoden, die verwendet werden können guckt in die Demo oder im Skript selber. Jede Methode hat einen Kommentar-Header, der erklärt was die Methode macht.

FAQ

Nüx..

Kompabilität

Das Skript ist nicht SDK-konform, zumindest momentan nicht, kann sich in der Zukunft ändern. Solange ihr aber kein anderes Skript benutzt, das ein Modul oder eine Klasse mit dem Namen "Mouse" benutzt, sollte dieses Skript hier mit allen anderen zusammen laufen.
Vermeidet es zwei oder mehr Spiele, die dieses Skript benutzen gleichzeitig im Testmodus zu starten. Obwohl ich es mit 2 gleichzeitig laufenden Spielen ohne Probleme getestet habe, kann ich nicht garantieren, daß das Skript unter diesen Umständen funktioniert.

Credits

Hier geht ein Danke Schön an cybersam, der das Skript überhaupt anfangs geschrieben hat und die Koordinaten auch im Fenstermodus korrekt berechnen konnte. Ein weiteres Danke geht an Kai fürs Hosten der Demo.

Anmerkungen

Ich hoffe ihr findet dieses Skript, ebenso wie ich, einfacher zu benutzen als das Orginale. Ich habe ausserdem das entfernt, was ich "schlechten Programmierstil" nennen würde, wie jede Menge globale Variablen zu benutzen, wo es überhaupt nicht notwendig ist. Ich ermutige also jeden von diesem Skript etwas zu lernen. Sei es Ruby, RGSS oder einfach nur vernünftiger Programmierstil =).

Das Skript darf auch in kommerziellen (Shareware) oder verschlüsselten Spielen verwendet werden, sofern Credits gegeben werden (cybersam und mir), das ist jedenfalls meine Stellung dazu. Zur Sicherheit sollte man da aber vielleicht bei cybersam nochmal nachfragen.

[Ascare]

Das ist diese Woche schon die zweite tolle Nachricht von dir.
Das Script klappt bei mir sehr gut. Ich werde es sehr wahrscheinlich für mein Spiel verwenden.

[Kelven]

Der Thread ist zwar schon uralt, aber egal. Ich schaffe es im Moment nicht, das Script zum Laufen zu bekommen. Wie muss denn der Dateiname angegeben werden? Nehme ich direkt den Namen, meckert der XP, dass es sich um eine unbekannte Variable handelt. Setze ich den Namen in Anführungszeichen, sagt der XP, dass ich Nil nicht in einen String umwandeln kann.

[Linkey]

Mouse.setCursor("bild.png") sollte funktionieren. Das Bild muss im Pictures-Ordner liegen.

[Kelven]

Leider nein, dann meldet er auch den Typfehler.

[-KD-]

Das Script scheint etwas buggy zu sein. Ersetze mal im Script sämtliche Aufrufe

Code:

initSystem(nil)

durch

Code:

initSystem()

evtl. hilft das.

Falls nicht, poste mal deinen Code und die genaue Fehlermeldung.

[Kelven]

Dadurch tritt der Fehler nicht mehr auf, aber leider bewegt sich der Cursor nicht. Welches Mausscript wird denn sonst so bei XP-Spielen benutzt?

[Cornix]

Was für eine Funktionalität benötigst du denn genau, beziehungsweise wie gut kennst du dich mit Ruby aus?
Ich hatte in diversen Projekten ziemliche gute Erfolge mit meinem Mausscript, da gab es nie irgendwelche Beschwerden.
Allerdings sehr viel Eigenarbeit. Das ist nichts poliertes und nichts angepasstes.

[Skorp]

Ohne es selbst bisher ausprobiert zu haben, soll das ganz gut funktionieren:

Code:

############################################################################
# Script by: BEHEMOTH #                                                     #
#######################                                                     #
# Script: Mouse Module (Requires Window Module)                             #
# Current Version: 1.1                                                      #
#                                                                           #
# * Version 1.1                                                             #
#     - Fixed Mouse_Buttons from Array To Table                             #
#                                                                           #
# * Version 1.0                                                             #
#     - get/set the mouse position                                          #
#     - get mouse button input                                              #
#                                                                           #
#############################################################################

#############################################################################
#                          ***Script Commands***                            #
#                                                                           #
# Mouse.press?(key)                                                         #
# Mouse.trigger?(key)                                                       #
# Mouse.repeat?(key)                                                        #
# Mouse.release?(key)                                                       #
# Mouse.show                                                                #
# Mouse.hide                                                                #
# Mouse.screen_pos_x                                                        #
# Mouse.screen_pos_y                                                        #
# Mouse.set_pos(x, y)                                                       #
# Mouse.pos_x                                                               #
# Mouse.pos_y                                                               #
#                                                                           #
#           ***Script commands intended for parrel processes***             #
#                   ***and/or loops inside scripts***                       #
#                                                                           #
# Mouse.update                                                              #
#                                                                           #
#############################################################################
module Mouse
  Mouse_Buttons = Table.new(3)
  Left_Click   = Mouse_Buttons[0] = 1
  Right_Click  = Mouse_Buttons[1] = 2
  Middle_Click = Mouse_Buttons[2] = 4

  @press = []
  @trigger = []
  @repeat = []
  @release = []
  @repeat_time = Table.new(255)
  @release_num = Table.new(255)
  
  REPEAT_TIME = 15
  REPEAT_PAUSE = 3
  
  @@cursor_pos = Win32API.new('user32', 'GetCursorPos', 'p', 'i')
  @@set_cursor_pos = Win32API.new('user32', 'SetCursorPos', 'ii', 'i')
  @@show_cursor = Win32API.new('user32', 'ShowCursor', 'L', 'i')
  State = Win32API.new("user32", "GetKeyState", 'i', 'i')
  Key = Win32API.new("user32", "GetAsyncKeyState", 'i', 'i')
  #-------------------------------------------------------------------------
  # Shows Mouse Cursor
  #-------------------------------------------------------------------------
  def Mouse.show
    @@show_cursor.call(-1)
  end
  #-------------------------------------------------------------------------
  # Hides Mouse Cursor
  #-------------------------------------------------------------------------
  def Mouse.hide
    @@show_cursor.call(0)
  end
  #-------------------------------------------------------------------------
  # Checks if a key is being pressed and if it isn't anymore then is released
  #-------------------------------------------------------------------------
  def Mouse.check_press?(key)
    if not State.call(key).between?(0, 1)
      @release_num[key] = 1
      return true
    end
    if @release_num[key] == 1
      @release_num[key] = 0
      @release.push(key)
    end
    return false
  end
  #-------------------------------------------------------------------------
  def Mouse.check_trigger?(key)
    return Key.call(key) & 0x01 == 1
  end
  #-------------------------------------------------------------------------
  def Mouse.check_repeat?(key)
    if @trigger.include?(key)
      return true
    elsif (not @trigger.include?(key)) && @press.include?(key)
      if @repeat_time[key] >= REPEAT_TIME
        @repeat_time[key] -= REPEAT_PAUSE
        return true
      else
        @repeat_time[key]+=1
        return false
      end
    else
      @repeat_time[key] = 0
      return false
    end
  end
  #-------------------------------------------------------------------------
  def Mouse.press?(key)
    return @press.include?(key)
  end
  #-------------------------------------------------------------------------
  def Mouse.trigger?(key)
    return @trigger.include?(key)
  end
  #-------------------------------------------------------------------------
  def Mouse.repeat?(key)
    return @repeat.include?(key)
  end
  #-------------------------------------------------------------------------
  def Mouse.release?(key)
    return @release.include?(key)
  end
  #-------------------------------------------------------------------------
  # * Updates Mouse
  #-------------------------------------------------------------------------
  def Mouse.update
    Mouse.wheel
    @press = []
    @trigger = []
    @repeat = []
    @release = []
    for i in 0...Mouse_Buttons.xsize
      key_update(Mouse_Buttons[i])
    end
  end
  #-------------------------------------------------------------------------
  # * Updates Mouse's Key Input
  #-------------------------------------------------------------------------
  def Mouse.key_update(key)
    if check_press?(key)
      @press.push(key)
    end
    if check_trigger?(key)
      @trigger.push(key)
    end
    if check_repeat?(key)
      @repeat.push(key)
    end
  end
  #-------------------------------------------------------------------------
  # * Gets Mouse X Position, screen coordinate.
  #-------------------------------------------------------------------------
  def Mouse.screen_pos_x
    return screen_pos[0]
  end
  #-------------------------------------------------------------------------
  # * Gets Mouse X Position, screen coordinate.
  #-------------------------------------------------------------------------
  def Mouse.screen_pos_y
    return screen_pos[1]
  end
  #-------------------------------------------------------------------------
  # * Gets the mouse position relative to the screen
  #-------------------------------------------------------------------------
  def Mouse.screen_pos
    spos = [0, 0].pack('ll')
    @@cursor_pos.call(spos)
    return spos.unpack('ll')
  end
  #-------------------------------------------------------------------------
  # * Sets mouse position to the x, y
  #-------------------------------------------------------------------------
  def Mouse.set_pos(x, y)
    x = [[x, 0].max, 640].min
    y = [[y, 0].max, 480].min
    x, y = Win.client_to_screen(x, y)
    @@set_cursor_pos.call(x, y)
  end
  #-------------------------------------------------------------------------
  # * Gets the mouse position relative to the cilent
  #   If mouse is outside of client area then mouse position is -1, -1
  #-------------------------------------------------------------------------
  def Mouse.pos
    x, y = Win.screen_to_client(screen_pos_x, screen_pos_y)
    if x.nil?
      return -1, -1
    else
      width, height = Win.client_size
      if (x >= 0 and y >= 0 and x < width and y < height)
        return x, y
      else
        print("hello")
        return -1, -1
      end
    end
  end
  #-------------------------------------------------------------------------
  # Returns the Y coordinate relative to the client window
  #-------------------------------------------------------------------------
  def Mouse.pos_x
    return pos[0]
  end
  #-------------------------------------------------------------------------  
  # Returns the Y coordinate relative to the client window
  #-------------------------------------------------------------------------  
  def Mouse.pos_y
    return pos[1]
  end
  #-------------------------------------------------------------------------  
end

[-KD-]

Du musst in beiden Scripts jeden Frame die Mouse.update Methode aufrufen. Eine Möglichkeit, dass zu bewerkstelligen, wäre folgender Code:

Code:

class << Input
  alias update_without_mouse update
  def update
    update_without_mouse
    Mouse.update
  end
end

Dann sollte auch der Mauszeiger angezeigt werden.

Das Script zeigt allerdings keine Mauszeiger-Grafik an, wobei sich das leicht nachrüsten lässt. Ansonsten ist es aber besser geschrieben als Magors Script, welches ein paar Fehler im Code und imo auch im Design hat. Insbesondere ist es kritisch, dass in Magors Script die Maustasten nicht während des Mouse-Updates, sondern mehrfach innerhalb eines Frames abgefragt werden. Das ist einerseits nicht konsistent zu der Art und Weise wie in der RGSS Tasten abgefragt werden, es kann zum anderen aber auch dazu führen, dass Mausklicks manchmal nicht erkannt werden.

Am besten du sagst mal, was du genau brauchst.

[Kelven]

Ich hab über ein klassisches Point-and-Click-Adventure nachgedacht. Ohne bewegliche Figur a la Maniac Mansion, sondern mit First-Person-Perspektive. Das Script müsste also nichts weiter machen können, als die Position des Cursors und die gedrückte Maustaste zu ermitteln. Außerdem sollte sich der Cursor je nach Position verändern können, aber das braucht nicht mit Ruby implementiert werden. Es wäre mMn sogar besser, das über ein PP zu steuern (weil diese Funktion abhängig von der Map ist). Es sollte nur eine Funktion zum schnellen Ändern des Cursorbildes geben.

[Kelven]

Nochmal nachgefragt: Was müsste man denn in das von Skorp gepostete Script einbauen, um eine Mauszeiger-Grafik anzuzeigen? -KD- meinte ja, dass das nicht getan wird.