Maus Skript - Editiertes cybersam 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
Das englische RTP (1.02) wird benötigt.

Script

#==============================================================================
#
# 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:

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:

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::CURSOR_PIC
Die Datei ist als Picture importiert und demnach im Picture-Ordner zu finden. filename beinhaltet nur den Dateinamen.
Mouse::CURSOR_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::CURSOR_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:

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:

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):

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.

[Sephiroththe23]

Sehr schönes Skript, Magor, danke, dass du mir Arbeit ersparts - und dein Stil ist wirklich bedeutend leserlicher und hübscher, als der ursprüngliche :P

[Veyrne]

Kurz über KD's Whoisonline-Spuren aufgegriffen.

Das Script hatte ich mir vor längerer Zeit mal angesehen und ich bin auch mal wieder überrascht wie simpel man gewisse Dinge mit dem RMXP umsetzen kann. (Besonders wo ich nicht sonderlich viel Ahnung vom RGSS habe.) Anhand des Testspiels kann man schon erahnen das die weitere Handhabung über ein gesamtes Game verteilt sehr einfach sein müsste. Hätte zwar gern ein praktisches Beispiel gesehen, aber ich denke das kann man sich mit der Hilfe des Testspiels schnell selbst basteln.

[MagicMagor]

Ehrlich gesagt arbeite ich ja gerade an einem GUI-Kit, was erlaubt ein komplettes Interface, das mit der Maus gesteuert wird, zu erstellen. (und selbiges aus einem XML-Dokument zu lesen)

Das Maus-Skript stellt nur eine Basis, auf der man natürlich aufbauen kann.

[DragonRPG]

Hm, und wo bekomme ich das benötigte RTP?

[MagicMagor]

Wenn du die Trial/VV installiert hast, ist es eh schon installiert. Ansonsten hier:
www.rpg-makerxp.com (offzielle Seite)

[Lorion]

Hallo Magic Magor,

Hab zu dem Maus Skript nen fehler gefunden .
Wenn ich das Spiel ganz normal öffnet und das Spiel teste geht
alles wunderbar aber wenn man:

-Das Spiel speichert und beendet.
-Dann das Spiel wieder neu Starten.
-Und dann dein gespeichertes Spiel ladest kommt folgende fehler meldung.


TypeError occurred while running scipt

Connot convert nil into string


Habt ihr das auch oder ist das nur bei mir so ?
Need help

[Lorion]

hi,

Ok, hab den fehler, dumm von mir...
man muss beim Speichern darauf achten das
der Edit Event wieder auf Page 1 ist ....

[ddd]

Ich weiß, der Thread ist schon uralt, aber ich habe ein Problem mit dem Script: Wenn ich das Spiel starte und dann auf neues Spiel drücke (Mit den Tasten) kommt eine Fehlermeldung:

"NameError occurred while running script.
uninitalized constant Interpreter::CURSOR_PIC"

Ich kann leider nicht in der Demo nachschauen, da der Link mich immer auf irgendeine Seite führt, die wirklich überhauptnichts mit dem RPG Maker zu tun hat. (Oder ich hab was übersehen, glaub ich aber nicht)

Würde mich sehr freuen, wenn ihr mir helfen könntet!

[kaneluzifer]

kannste vergessen der gute MagicMagor antwortet nicht mehr ...
und die demo ist leider down

[MagicMagor]

kannste vergessen der gute MagicMagor antwortet nicht mehr ...

Ja, ich war längere Zeit nicht mehr in der Szene aktiv. Sorry daß ich so spät antworte, aber besser als spät als nie heißt es ja so schön.
Hoffe das meine Antwort doch noch dem ein oder anderem hilft.

Ich weiß, der Thread ist schon uralt, aber ich habe ein Problem mit dem Script: Wenn ich das Spiel starte und dann auf neues Spiel drücke (Mit den Tasten) kommt eine Fehlermeldung:

"NameError occurred while running script.
uninitalized constant Interpreter::CURSOR_PIC"

Das Skript muss als eigenständiges Skript im Skript-Editor eingefügt werden falls du das nicht getan hast.
Ansonsten kann ich mir nur denken, daß du in einem Event die Konstante "CURSOR_PIC" benutzt, du musst allerdings "Mouse::CURSOR_PIC" schreiben, da die Konstante innerhalb des Mouse-Moduls definiert ist.
Falls das auch nicht der Fehler ist: Bitte den Rubycode posten den du in einem Event ausführen lässt.

Wegen der Demo guck ich mal ob ich sie noch auf der Platte habe, falls ja werde ich sie woanders hochladen.

Edit:
Hab die Demo noch auf meiner Platte gefunden und kurz überprüft, neu hochgeladen und neu verlinkt. Der Link im ersten Post sollte jetzt wieder funktionieren.

[_Matrix]

Ich finde Das Script echt toll. Leider ist es von einer einfachen Anwendung noch weit entfernt. Ich könnte es evtl. Erweitern falls Interesse besteht.

Ich hab hab mal kurz ein Script geschrieben, was Prüft, ob sich die Maus über einem Bild befindet. Ich glaube das hilft bei der eigenen Menügestalltung schon mal sehr.

EDIT:
Ich arbeite gerade an einer Überarbeitung des Scripts.

[derula]

Zitat von _Matrix

Ich finde Das Script echt toll. Leider ist es von einer einfachen Anwendung noch weit entfernt. Ich könnte es evtl. Erweitern falls Interesse besteht.

Ich finde das Skript echt beschissen. Einer Modifikation eines Skripters deinen Kalibers kaum würdig. Mach lieber ein neues Skript (Grundidee mit Windows-API kannst du gerne aus obigem Skript übernehmen, aber es reichen imho weniger WinAPI-Funktionen aus - GetWindowRect und GetClientRect sind meiner Meinung nach durch ScreenToClient komplett überflüssig).

[_Matrix]

Zitat von derula

Ich finde das Skript echt beschissen. Einer Modifikation eines Skripters deinen Kalibers kaum würdig. Mach lieber ein neues Skript.

Das hört sich irgendwie so an als wenn ich das wirklich machen müsste um meinen Stolz zu waren.^^
Ich werd mich am WE mal dransetzen.
Dann bau ich auch gleich eine Anwendung für Standart-Auswahlfenster ein.

Zitat von derula

...GetWindowRect und GetClientRect sind meiner Meinung nach durch ScreenToClient komplett überflüssig).

GetWindowRect wird tatsächlich garnicht benutzt.
GetClientRect im Gegensatz schon, um zu Prüfen ob die Maus innerhalb des Fensters liegt.

Nebenbei hat das Script wirklich einige unnötige Zeilen.

[derula]

Zitat von _Matrix

GetClientRect im Gegensatz schon, um zu Prüfen ob die Maus innerhalb des Fensters liegt.

Naja okay, wenn man natürlich unterschiedliche Fenstergrößen unterstützen will ist das nicht unpraktisch. Bei meinem Skript habe ich das allerdings so gelöst: Wenn die Maus aus dem Fenster rausbewegt wird, wird eben auch der Cursor dorthin bewegt. Das macht ja nix und der Spieler kriegt es auch nicht mit. Stört keinen. Nur wenn der Cursor über die Titelleiste bewegt wird braucht man ein Extraverhalten: Dann muss der richtige Mauszeiger angezeigt werden. Aber ob sich die Maus oberhalb des Clientbereichs befindet, lässt sich einfach mit ner Abfrage y<0 lösen.

Es ist also nur wichtig zu wissen, ob sich die Maus oberhalb des Clientbereiches befindet, und dazu braucht man kein GetClientRect.

Edit: Hatte ganz vergessen dass ich mein Skript veröffentlicht hatte. Kannst natürlich auch die Standardklassen darauf umstellen wenn du willst.