SHARE
TWEET

[XP][VX][VXA] Rpg.NET Wrapper

ForeverZer0 Jul 30th, 2014 539 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
  2. # Rpg.NET Wrapper
  3. # Author: ForeverZer0
  4. # Version: 0.28A
  5. # Date: 7.30.2014
  6. #=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
  7. #                             VERSION HISTORY
  8. #=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
  9. # - Developer Release, no history until full public release.
  10. #=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
  11. #
  12. # Introduction:
  13. #
  14. #   Rpg.NET is an API built using the .NET Framework for both improving
  15. #   performance and enhancing the RPG Maker series (XP, VX, and VXA). Contained
  16. #   within are various functions and classes that extend the ability of RPG
  17. #   Maker in areas such as graphics, audio, and Windows API interop. Included is
  18. #   a Ruby script that is the wrapper around the library, so it can be used as
  19. #   any other script within your game.
  20. #
  21. # Features:
  22. #
  23. #   A whole bunch, and growing. Will update this for full release.
  24. #
  25. # Instructions:
  26. #
  27. #   - Place Rpg.NET.dll in your game folder
  28. #   - If renaming, update RPGNET constant below
  29. #
  30. # Compatibility:
  31. #
  32. #   - RPG Maker XP, VX, and VXA
  33. #   - Rpg.NET Input Module is likely not compatible with other Input scripts
  34. #   - No know compatibility issues with other scripts.
  35. #
  36. # Credits/Thanks:
  37. #
  38. #   - ForeverZer0, for the script
  39. #
  40. # Authors Notes:
  41. #
  42. #   - This is NOT A FINAL RELEASE, and it is advised not to distribute with your
  43. #     game as such. It is not fully tested, not complete, so various bugs may
  44. #     yet be found.
  45. #=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
  46.  
  47. #===============================================================================
  48. # ** RpgNET
  49. #-------------------------------------------------------------------------------
  50. # Module wrapper for Rpg.NET utility functions.
  51. #===============================================================================
  52.  
  53. # Relative name and path of the Rpg.NET library.
  54. RPGNET = 'Rpg.NET.dll'
  55.  
  56. module RpgNET
  57.   #-----------------------------------------------------------------------------
  58.   # * Constants
  59.   #-----------------------------------------------------------------------------
  60.   CopyGameWindow = Win32API.new(RPGNET, 'BmCopyGameWindow', 'ii', '')
  61.   GetWindowRect = Win32API.new(RPGNET, 'GetWindowRect', 'pi', '')
  62.   OpenFileDlg = Win32API.new(RPGNET, 'OpenFileDlg', 'p', 'p')
  63.   RgssEval = Win32API.new(RPGNET, 'RgssEval', 'p', '')
  64.   ShowScriptWindow = Win32API.new(RPGNET, 'ShowScriptWindow', '', '')
  65.   #-----------------------------------------------------------------------------
  66.   # * Initialize Rpg.NET Core
  67.   #-----------------------------------------------------------------------------
  68.   def self.initialize
  69.     version = 0
  70.     if RUBY_VERSION == '1.8.1'
  71.       version = defined?(Hangup) ? 1 : 2
  72.     elsif RUBY_VERSION == '1.9.2'
  73.       version = 4
  74.     end
  75.     Win32API.new(RPGNET, 'Initialize', 'i', '').call(version)
  76.   end
  77.   #-----------------------------------------------------------------------------
  78.   # * Open Script Window
  79.   #-----------------------------------------------------------------------------
  80.   def self.show_script_window
  81.     ShowScriptWindow.call
  82.   end
  83.   #-----------------------------------------------------------------------------
  84.   # * Send Message to Rpg.NET Core  
  85.   #     code : Code to evaluate within the RGSS scope and return
  86.   #
  87.   #                      ** INTERNAL USE ONLY ***
  88.   #-----------------------------------------------------------------------------
  89.   def self.send_message(code)
  90.     begin
  91.       result = eval(code)
  92.       unless result.is_a?(String)
  93.         result = result.to_s
  94.       end
  95.       RgssEval.call(result)
  96.     rescue
  97.       RgssEval.call('')
  98.     end
  99.   end  
  100.   #-----------------------------------------------------------------------------
  101.   # * Show Open File Dialog
  102.   #     filter : Filter to determine available files to open.
  103.   #-----------------------------------------------------------------------------
  104.   def self.open_file_dialog(filter = 'All Files|*.*')
  105.     return OpenFileDlg.call(filter)
  106.   end
  107.   #-----------------------------------------------------------------------------
  108.   # * Get Full Path to Local/RTP Resource
  109.   #     filename  : Filename to search for, without extension
  110.   #     subfolder : Relative subfolder where file is located
  111.   #-----------------------------------------------------------------------------
  112.   def self.get_full_path(filename, subfolder)
  113.     api = Win32API.new(RPGNET, 'GetFullPath', 'pp', 'p')
  114.     return api.call(filename, subfolder)
  115.   end
  116.   #-----------------------------------------------------------------------------
  117.   # * Show Console Output Window
  118.   #-----------------------------------------------------------------------------
  119.   def self.show_console
  120.     Win32API.new(RPGNET, 'ShowConsole', '', '').call
  121.   end
  122.   #-----------------------------------------------------------------------------
  123.   # * Hide Console Output Window
  124.   #-----------------------------------------------------------------------------
  125.   def self.hide_console
  126.     # TODO: Implement
  127.   end
  128.   #-----------------------------------------------------------------------------
  129.   # * Get RTP Path
  130.   #     index : Index of the RTP whose path to retrieve (XP Only)
  131.   #-----------------------------------------------------------------------------
  132.   def self.get_rtp_path(index = 0)
  133.     return Win32API.new(RPGNET, 'GetRtpPath', 'i', 'p').call(index)
  134.   end
  135.   #-----------------------------------------------------------------------------
  136.   # * Set Window Resolution
  137.   #     width  : Width of the new client area of the window to set
  138.   #     height : Height of the new client area of the window to set
  139.   #-----------------------------------------------------------------------------
  140.   def self.set_resolution(width, height)
  141.     Win32API.new(RPGNET, 'SetResolution', 'ii', '').call(width, height)
  142.   end
  143.   #-----------------------------------------------------------------------------
  144.   # * Set Window Icon
  145.   #     icon : Bitmap to use as window icon, or file to a image or *.ico file.
  146.   #            Bitmaps must be either 48x48, 128x128, or 256x256.
  147.   #-----------------------------------------------------------------------------
  148.   def self.set_window_icon(icon)
  149.     if icon.is_a?(String)
  150.       Win32API.new(RPGNET, 'SetIconFile', 'p', '').call(icon)
  151.     elsif icon.is_a?(Bitmap)
  152.       Win32API.new(RPGNET, 'SetIconBitmap', 'i', '').call(icon.__id__)
  153.     end
  154.   end
  155.   #-----------------------------------------------------------------------------
  156.   # * Get Window Rectangle
  157.   #     frame : Flag indiciating if window frame will be included in rectangle
  158.   #-----------------------------------------------------------------------------
  159.   def self.get_window_rect(frame = false)
  160.     rect = [0, 0, 0, 0].pack('l4')
  161.     GetWindowRect.call(rect, frame ? 1 : 0)
  162.     return Rect.new(*rect.unpack('l4'))
  163.   end
  164.   #-----------------------------------------------------------------------------
  165.   # * Get Screenshot
  166.   #     frame : Flag indiciating if window frame will be included in image.
  167.   #-----------------------------------------------------------------------------
  168.   def self.window_bitmap(frame = false)
  169.     rect = [0, 0, 0, 0].pack('l4')
  170.     GetWindowRect.call(rect, frame ? 1 : 0)
  171.     x, y, w, h = rect.unpack('l4')
  172.     bitmap = Bitmap.new(w, h)
  173.     CopyGameWindow.call(bitmap.__id__, frame ? 1 : 0)
  174.     return bitmap
  175.   end
  176.   #-----------------------------------------------------------------------------
  177.   # * Save Screenshot
  178.   #     filename : Path where image will be saved. (*.jpg, *.png, *.bmp, *.gif)
  179.   #     frame    : Flag indiciating if window frame will be included in image.
  180.   #-----------------------------------------------------------------------------
  181.   def self.screenshot(filename, frame = false)
  182.     screen = self.window_bitmap(frame)
  183.     screen.save(filename)
  184.     screen.dispose
  185.   end
  186. end
  187.  
  188. ################################################################################
  189. #              DO NOT REMOVE! REQUIRED FOR LIBRARY TO WORK!
  190. ################################################################################
  191.                           RpgNET.initialize
  192. ################################################################################
  193. #              DO NOT REMOVE! REQUIRED FOR LIBRARY TO WORK!
  194. ################################################################################
  195.  
  196. #===============================================================================
  197. # ** Bitmap
  198. #-------------------------------------------------------------------------------
  199. # The bitmap class. Bitmaps are expressions of so-called graphics.
  200. #===============================================================================
  201.  
  202. class Bitmap
  203.   #-----------------------------------------------------------------------------
  204.   # * Constants
  205.   #-----------------------------------------------------------------------------
  206.   Save = Win32API.new(RPGNET, 'BmSave', 'ip', '')
  207.   Filter = Win32API.new(RPGNET, 'BmFilter', 'iiiiii', '')
  208.   Load = Win32API.new(RPGNET, 'BmLoad', 'pp', '')
  209.   GetLoaded = Win32API.new(RPGNET, 'BmGetLoaded', 'i', '') # lol
  210.   DrawArc = Win32API.new(RPGNET, 'BmDrawArc', 'iiiiiiiii', '')
  211.   DrawBezier = Win32API.new(RPGNET, 'BmDrawBezier', 'iiiiiiiiii', '')
  212.   DrawBeziers = Win32API.new(RPGNET, 'BmDrawBezier', 'iip', '')
  213.   DrawClosedCurve = Win32API.new(RPGNET, 'BmDrawClosedCurve', 'iiipp', '')
  214.   DrawCurve = Win32API.new(RPGNET, 'BmDrawCurve', 'iiiipp', '')
  215.   DrawEllipse = Win32API.new(RPGNET, 'BmDrawEllipse', 'iiiiiii', '')
  216.   DrawLine = Win32API.new(RPGNET, 'BmDrawLine', 'iiiiiii', '')
  217.   DrawLines = Win32API.new(RPGNET, 'BmDrawLine', 'iiip', '')
  218.   DrawPolygon = Win32API.new(RPGNET, 'BmDrawPolygon', 'iiip', '')
  219.   DrawPie = Win32API.new(RPGNET, 'BmDrawPie', 'iiiiiiiii', '')
  220.   FillClosedCurve = Win32API.new(RPGNET, 'BmFillClosedCurve', 'iipp', '')
  221.   FillEllipse = Win32API.new(RPGNET, 'BmFillEllipse', 'iiiiii', '')
  222.   FillPie = Win32API.new(RPGNET, 'BmFillPie', 'iiiiiiii', '')
  223.   FillPolygon = Win32API.new(RPGNET, 'BmFillPolygon', 'iip', '')
  224.   FillGradientRect = Win32API.new(RPGNET, 'BmFillGradientRect', 'iiiiiiip', '')
  225.   FillGradientEllipse = Win32API.new(RPGNET, 'BmFillGradientEllipse', 'iiiiiiip', '')
  226.   FillGradientPolygon = Win32API.new(RPGNET, 'BmFillGradientPolygon', 'iiipp', '')
  227.   Invert = Win32API.new(RPGNET, 'BmInvert', 'ii', '')
  228.   Pixelate = Win32API.new(RPGNET, 'BmPixelate', 'iii', '')
  229.   ChangeRgba = Win32API.new(RPGNET, 'BmChangeRgba', 'iii', '')
  230.   GaussianBlur = Win32API.new(RPGNET, 'BmGaussianBlur', 'iip', '')
  231.   Blur = Win32API.new(RPGNET, 'BmBlur', 'iip', '')
  232.   Sharpen = Win32API.new(RPGNET, 'BmSharpen', 'iip', '')
  233.   Soften = Win32API.new(RPGNET, 'BmSoften', 'i', '')
  234.   EdgeDetect = Win32API.new(RPGNET, 'BmEdgeDetect', 'iii', '')
  235.   PosterEffect = Win32API.new(RPGNET, 'BmPosterEffect', 'i', '')
  236.   Sepia = Win32API.new(RPGNET, 'BmSepia', 'i', '')
  237.   HighPass = Win32API.new(RPGNET, 'BmHighPass', 'ii', '')
  238.   Grayscale = Win32API.new(RPGNET, 'BmGrayscale', 'ii', '')
  239.   Emboss = Win32API.new(RPGNET, 'BmEmboss', 'iii', '')
  240.   Tint = Win32API.new(RPGNET, 'BmTint', 'iiii', '')
  241.   ColorBalance = Win32API.new(RPGNET, 'BmColorBalance', 'iiii', '')
  242.   Bitonal = Win32API.new(RPGNET, 'BmBitonal', 'iiii', '')
  243.   Solarise = Win32API.new(RPGNET, 'BmSolarise', 'iiii', '')
  244.   MedianFilter = Win32API.new(RPGNET, 'BmMedianFilter', 'iiii', '')
  245.   DrawTextVertical = Win32API.new(RPGNET, 'BmDrawTextV', 'iiiiipipiiii', '')
  246.   DrawTextGradient = Win32API.new(RPGNET, 'BmDrawGradientText', 'iiiiipipiiiii', '')
  247.   DrawTextGradientV = Win32API.new(RPGNET, 'BmDrawGradientTextV', 'iiiiipipiiiiii', '')
  248.   ColorMask = Win32API.new(RPGNET, 'BmColorMask', 'iii', '')
  249.   Search = Win32API.new(RPGNET, 'BmSearch', 'iipp', '')
  250.   RotateFlip = Win32API.new(RPGNET, 'BmRotateFlip', 'ii', '')
  251.   #-----------------------------------------------------------------------------
  252.   # * Public Instance Variables
  253.   #-----------------------------------------------------------------------------
  254.   attr_reader :hue
  255.   attr_reader :saturation
  256.   attr_reader :contrast
  257.   attr_reader :brightness
  258.   attr_reader :gamma
  259.   attr_reader :red
  260.   attr_reader :green
  261.   attr_reader :blue
  262.   attr_reader :alpha
  263.   #-----------------------------------------------------------------------------
  264.   # * Object Initialization
  265.   #-----------------------------------------------------------------------------
  266.   alias effects_init initialize
  267.   def initialize(*args)
  268.     @hue = 0
  269.     @saturation = 100
  270.     @contrast = 100
  271.     @brightness = 100
  272.     @gamma = 100
  273.     @red = 0
  274.     @green = 0
  275.     @blue = 0
  276.     @alpha = 0
  277.     effects_init(*args)
  278.   end
  279.   #-----------------------------------------------------------------------------
  280.   # * Set Red Component Offset
  281.   #     value : Offset to apply to pixel component. (-255..255)
  282.   #-----------------------------------------------------------------------------
  283.   def red=(value)
  284.     if @red != value
  285.       @red = value
  286.       ChangeRgba.call(__id__, value, 2)
  287.     end
  288.   end
  289.   #-----------------------------------------------------------------------------
  290.   # * Set Green Component Offset
  291.   #     value : Offset to apply to pixel component. (-255..255)
  292.   #-----------------------------------------------------------------------------
  293.   def green=(value)
  294.     if @green != value
  295.       @green = value
  296.       ChangeRgba.call(__id__, value, 1)
  297.     end
  298.   end
  299.   #-----------------------------------------------------------------------------
  300.   # * Set Blue Component Offset
  301.   #     value : Offset to apply to pixel component. (-255..255)
  302.   #-----------------------------------------------------------------------------
  303.   def blue=(value)
  304.     if @blue != value
  305.       @blue = value
  306.       ChangeRgba.call(__id__, value, 0)
  307.     end
  308.   end
  309.   #-----------------------------------------------------------------------------
  310.   # * Set Alpha Component Offset
  311.   #     value : Offset to apply to pixel component. (-255..255)
  312.   #-----------------------------------------------------------------------------
  313.   def alpha=(value)
  314.     if @alpha != value
  315.       @alpha = value
  316.       ChangeRgba.call(__id__, value, 3)
  317.     end
  318.   end
  319.   #-----------------------------------------------------------------------------
  320.   # * Apply Multiple Filters (Destructive)
  321.   #     hue        : Set the hue level. (Clamped between 0 and 360)
  322.   #     saturation : Set the saturation level. (Clamped between 0 and 200)
  323.   #     brightness : Set the brightness level. (Clamped between 0 and 200)
  324.   #     contrast   : Set the contrast level. (Clamped between 1 and 400)
  325.   #     gamma      : Set the gamma level. (Clamped between 1 and 400)
  326.   #-----------------------------------------------------------------------------
  327.   def apply_filter!(hue, saturation, brightness, contrast, gamma)
  328.     @hue = [[0, hue].max, 360].min
  329.     @saturation = [[0, saturation].max, 200].min
  330.     @brightness = [[0, brightness].max, 200].min
  331.     @contrast = [[1, contrast].max, 400].min
  332.     @gamma = [[1, gamma].max, 400].min
  333.     Filter.call(__id__, @hue, @saturation, @brightness, @contrast, @gamma)
  334.   end
  335.   #-----------------------------------------------------------------------------
  336.   # * Apply Multiple Filters (Non-Destructive)
  337.   #     hue        : Set the hue level. (Clamped between 0 and 360)
  338.   #     saturation : Set the saturation level. (Clamped between 0 and 200)
  339.   #     brightness : Set the brightness level. (Clamped between 0 and 200)
  340.   #     contrast   : Set the contrast level. (Clamped between 1 and 400)
  341.   #     gamma      : Set the gamma level. (Clamped between 1 and 400)
  342.   #-----------------------------------------------------------------------------
  343.   def apply_filter(hue, saturation, brightness, contrast, gamma)
  344.     bitmap = self.clone
  345.     bitmap.apply_filter!(hue, saturation, brightness, contrast, gamma)
  346.     return bitmap
  347.   end
  348.   #-----------------------------------------------------------------------------
  349.   # * Apply Hue Filter (Destructive)
  350.   #     value : Set the hue level. (Clamped between 0 and 360)
  351.   #-----------------------------------------------------------------------------
  352.   def set_hue!(value)
  353.     @hue = [[0, value].max, 360].min
  354.     Filter.call(__id__, @hue, 100, 100, 100, 100)
  355.   end
  356.   #-----------------------------------------------------------------------------
  357.   # * Apply Hue Filter (Non-Destructive)
  358.   #     value : Set the hue level. (Clamped between 0 and 360)
  359.   #-----------------------------------------------------------------------------
  360.   def set_hue(value)
  361.     bitmap = self.clone
  362.     @hue = [[0, value].max, 360].min
  363.     Filter.call(bitmap._id__, @hue, 100, 100, 100, 100)
  364.     return bitmap
  365.   end
  366.   #-----------------------------------------------------------------------------
  367.   # * Apply Saturation Filter (Destructive)
  368.   #     value : Set the saturation level. (Clamped between 0 and 200)
  369.   #-----------------------------------------------------------------------------
  370.   def set_saturation!(value)
  371.     @saturation = [[0, value].max, 200].min
  372.     Filter.call(__id__, 0, @saturation, 100, 100, 100)
  373.   end
  374.   #-----------------------------------------------------------------------------
  375.   # * Apply Saturation Filter (Non-Destructive)
  376.   #     value : Set the saturation level. (Clamped between 0 and 200)
  377.   #-----------------------------------------------------------------------------
  378.   def set_saturation=(value)
  379.     bitmap = self.clone
  380.     @saturation = [[0, value].max, 200].min
  381.     Filter.call(bitmap.__id__, 0, @saturation, 100, 100, 100)
  382.     return bitmap
  383.   end
  384.   #-----------------------------------------------------------------------------
  385.   # * Apply Brightness Filter (Destructive)
  386.   #     value : Set the brightness level. (Clamped between 0 and 200)
  387.   #-----------------------------------------------------------------------------
  388.   def set_brightness!(value)
  389.     @brightness = [[0, value].max, 200].min
  390.     Filter.call(__id__, 0, 100, @brightness, 100, 100)
  391.   end
  392.   #-----------------------------------------------------------------------------
  393.   # * Apply Brightness Filter (Non-Destructive)
  394.   #     value : Set the brightness level. (Clamped between 0 and 200)
  395.   #-----------------------------------------------------------------------------
  396.   def set_brightness=(value)
  397.     bitmap = self.clone
  398.     @brightness = [[0, value].max, 200].min
  399.     Filter.call(bitmap.__id__, 0, 100, @brightness, 100, 100)
  400.     return bitmap
  401.   end
  402.   #-----------------------------------------------------------------------------
  403.   # * Apply Contrast Filter (Destructive)
  404.   #     value : Set the contrast level. (Clamped between 1 and 200)
  405.   #-----------------------------------------------------------------------------
  406.   def set_contrast!(value)
  407.     @contrast = [[1, value].max, 400].min
  408.     Filter.call(__id__, 0, 100, 100, @contrast, 100)
  409.   end
  410.   #-----------------------------------------------------------------------------
  411.   # * Apply Contrast Filter (Non-Destructive)
  412.   #     value : Set the contrast level. (Clamped between 1 and 200)
  413.   #-----------------------------------------------------------------------------
  414.   def set_contrast(value)
  415.     bitmap = self.clone
  416.     @contrast = [[1, value].max, 400].min
  417.     Filter.call(bitmap.__id__, 0, 100, 100, @contrast, 100)
  418.     return bitmap
  419.   end
  420.   #-----------------------------------------------------------------------------
  421.   # * Apply Gamma Filter (Destructive)
  422.   #     value : Set the gamma level. (Clamped between 1 and 400)
  423.   #-----------------------------------------------------------------------------
  424.   def set_gamma!(value)
  425.     @gamma = [[1, value].max, 400].min
  426.     Filter.call(__id__, 0, 100, 100, 100, @gamma)
  427.   end
  428.   #-----------------------------------------------------------------------------
  429.   # * Apply Gamma Filter (Non-Destructive)
  430.   #     value : Set the gamma level. (Clamped between 1 and 400)
  431.   #-----------------------------------------------------------------------------
  432.   def set_gamma(value)
  433.     bitmap = self.clone
  434.     @gamma = [[1, value].max, 400].min
  435.     Filter.call(bitmap.__id__, 0, 100, 100, 100, @gamma)
  436.     return bitmap
  437.   end
  438.   #-----------------------------------------------------------------------------
  439.   # * Save Bitmap  
  440.   #     filename : Path to file (*.jpg, *.png, *.bmp, *.gif)
  441.   #-----------------------------------------------------------------------------
  442.   def save(filename)
  443.     Save.call(__id__, filename)
  444.   end
  445.   #-----------------------------------------------------------------------------
  446.   # * Load an Image File
  447.   #     filename : Supported formats: PNG, JPG, PSD, BMP, GIF, EXIF, TIFF
  448.   #-----------------------------------------------------------------------------
  449.   def self.open(filename)
  450.     struct = [0, 0].pack('l2')  
  451.     Load.call(filename, struct)
  452.     size = struct.unpack('l2')
  453.     bitmap = Bitmap.new(size[0], size[1])
  454.     GetLoaded.call(bitmap.__id__)
  455.     return bitmap
  456.   end
  457.   #-----------------------------------------------------------------------------
  458.   # * Bitmap Contains Bitmap
  459.   #     other     : Child Bitmap to check for
  460.   #     tolerance : Amount of variance allowed in comparison (0.0 = Exact)
  461.   #-----------------------------------------------------------------------------
  462.   def include?(other, tolerance = 0.0)
  463.     rect = find(other, tolerance)
  464.     return rect.width != 0 && rect.height != 0
  465.   end
  466.   #-----------------------------------------------------------------------------
  467.   # * Find Rect of Child Bitmap
  468.   #     other     : Child Bitmap to check for
  469.   #     tolerance : Amount of variance allowed in comparison (0.0 = Exact)
  470.   #-----------------------------------------------------------------------------
  471.   def find(bitmap, tolerance = 0.0)
  472.     rect = [0, 0, 0, 0].pack('l4')
  473.     Search.call(bitmap.__id__, __id__, tolerance.to_s, rect)
  474.     rect = rect.unpack('l4')
  475.     return Rect.new(*rect)
  476.   end
  477.   #-----------------------------------------------------------------------------
  478.   # * Draw Text Vertical
  479.   #     x         : x-coordinate of text
  480.   #     y         : y-coordinate of text
  481.   #     width     : Width of area to draw. Text will be centered horizontally.
  482.   #     height    : Height of area to draw text.
  483.   #     text      : String to draw.
  484.   #     align     : Text justificatiion. 0 = Left, 1 = Center, 2 = Right
  485.   #     direction : Text direction. 0 = Left, 1 = Right
  486.   #-----------------------------------------------------------------------------
  487.   def draw_text_vertical(x, y, width, height, text, align = 0, direction = 0)
  488.     style = 0
  489.     style |= 1 if self.font.bold
  490.     style |= 2 if self.font.italic
  491.     DrawTextVertical.call(__id__, x, y, width, height, text, align,
  492.       self.font.name, self.font.color.to_i, self.font.size, style, direction)
  493.   end
  494.    
  495.  
  496.   def draw_gradient_text(x, y, width, height, text, align = 0)
  497.     if self.font.gradient.nil?
  498.       white = Color.new(255, 255, 255)
  499.       self.font.gradient = Gradient.new(self.font.color, white, 90)
  500.     end
  501.     style = 0
  502.     style |= 1 if self.font.bold
  503.     style |= 2 if self.font.italic
  504.     g = self.font.gradient
  505.     DrawTextGradient.call(__id__, x, y, width, height, text, align,
  506.       self.font.name, g.color1.to_i, g.color2.to_i, g.angle, self.font.size, style)
  507.   end
  508.    
  509.    
  510.   def draw_gradient_text_vertical(x, y, width, height, text, align = 0, direction = 0)
  511.     if self.font.gradient.nil?
  512.       white = Color.new(255, 255, 255)
  513.       self.font.gradient = Gradient.new(self.font.color, white, 90)
  514.     end
  515.     style = 0
  516.     style |= 1 if self.font.bold
  517.     style |= 2 if self.font.italic
  518.     g = self.font.gradient
  519.     DrawTextGradientV.call(__id__, x, y, width, height, text, align,
  520.       self.font.name, g.color1.to_i, g.color2.to_i, g.angle, self.font.size,
  521.       style, direction)
  522.   end
  523.   #-----------------------------------------------------------------------------
  524.   # * Draw Arc
  525.   #     color       : Color used to draw
  526.   #     thickness   : Thickness, in pixels, of the pen used to draw
  527.   #     x           : x-coordinate
  528.   #     y           : y-coordinate
  529.   #     width       : width of the shape
  530.   #     height      : height of the shape
  531.   #     start_angle : Angle in degrees measured clockwise from the x-axis to the
  532.   #                   starting point of the arc
  533.   #     sweep_angle : Angle in degrees measured clockwise from the startAngle
  534.   #                   parameter to ending point of the arc
  535.   #-----------------------------------------------------------------------------
  536.   def draw_arc(color, thickness, x, y, width, height, start_angle, sweep_angle)
  537.     DrawArc.call(__id__, color.to_i, thickness, x, y, width, height,
  538.       start_angle, sweep_angle)
  539.   end
  540.   #-----------------------------------------------------------------------------
  541.   # * Draw Bezier
  542.   #     color     : Color used to draw
  543.   #     x1        : first x-coordinate
  544.   #     y1        : first y-coordinate
  545.   #     x2        : second x-coordinate
  546.   #     y2        : second y-coordinate
  547.   #     x3        : third x-coordinate
  548.   #     y3        : third y-coordinate
  549.   #     x4        : fourth x-coordinate
  550.   #     y4        : fourth y-coordinate
  551.   #-----------------------------------------------------------------------------
  552.   def draw_bezier(x1, y1, x2, y2, x3, y3, x4, y4, color)
  553.     DrawBezier.call(__id__, color.to_i, x1, y1, x2, y2, x3, y3, x4, y4)
  554.   end
  555.   #-----------------------------------------------------------------------------
  556.   # * Draw Beziers
  557.   #     color  : Color used to draw
  558.   #     points : Points used to draw shape, variable number of arguments.
  559.   #              No. of points should be multiple of 3 + 1, such as 4, 7, or 10.
  560.   #-----------------------------------------------------------------------------
  561.   def draw_beziers(color, *points)
  562.     DrawBeziers.call(__id__, color.to_i, points.join(','))
  563.   end
  564.   #-----------------------------------------------------------------------------
  565.   # * Draws Closed Curve
  566.   #     color     : Color used to draw
  567.   #     thickness : Thickness, in pixels, of the pen used to draw
  568.   #     tension   : Specifies the tension of the curve
  569.   #     points    : Points used to draw shape, variable number of arguments.
  570.   #-----------------------------------------------------------------------------
  571.   def draw_closed_curve(color, thickness, tension, *points)
  572.     DrawClosedCurve(__id__, color.to_i, thickness, tension.to_s, points.join(','))
  573.   end
  574.   #-----------------------------------------------------------------------------
  575.   # * Draw Curve
  576.   #     color     : Color used to draw
  577.   #     thickness : Thickness, in pixels, of the pen used to draw
  578.   #     tension   : Specifies the tension of the curve
  579.   #     points    : Points used to draw shape, variable number of arguments.
  580.   #-----------------------------------------------------------------------------
  581.   def draw_curve(color, thickness, tension, *points)
  582.     points = points.join(',')
  583.     DrawCurve.call(__id__, color.to_i, thickness, tension.to_s, points)
  584.   end
  585.   #-----------------------------------------------------------------------------
  586.   # * Draw Ellipse
  587.   #     color     : Color used to draw
  588.   #     thickness : Thickness, in pixels, of the pen used to draw
  589.   #     x         : x-coordinate
  590.   #     y         : y-coordinate
  591.   #     width     : width of the shape
  592.   #     height    : height of the shape
  593.   #-----------------------------------------------------------------------------
  594.   def draw_ellipse(color, thickness, x, y, width, height)
  595.     DrawEllipse.call(__id__, color.to_i, thickness, x, y, width, height)
  596.   end
  597.   #-----------------------------------------------------------------------------
  598.   # * Draw Line
  599.   #     x1        : first x-coordinate
  600.   #     y1        : first y-coordinate
  601.   #     x2        : second x-coordinate
  602.   #     y2        : second y-coordinate
  603.   #     color     : Color used to draw
  604.   #     thickness : Thickness, in pixels, of the pen used to draw
  605.   #-----------------------------------------------------------------------------
  606.   def draw_line(x1, y1, x2, y2, color, thickness)
  607.     DrawLine.call(__id__, x1, y1, x2, y2, color.to_i, thickness)
  608.   end
  609.   #-----------------------------------------------------------------------------
  610.   # * Draw Lines
  611.   #     color     : Color used to draw
  612.   #     thickness : Thickness, in pixels, of the pen used to draw
  613.   #     points    : Points used to draw shape, variable number of arguments.
  614.   #-----------------------------------------------------------------------------
  615.   def draw_lines(color, thickness, *points)
  616.     DrawLines.call(__id__, color.to_i, thickness, points.join(','))
  617.   end
  618.   #-----------------------------------------------------------------------------
  619.   # * Draw Polygon
  620.   #     color     : Color used to draw
  621.   #     thickness : Thickness, in pixels, of the pen used to draw
  622.   #     points    : Points used to draw shape, variable number of arguments.
  623.   #-----------------------------------------------------------------------------
  624.   def draw_polygon(color, thickness, *points)
  625.     DrawPolygon.call(__id__, color.to_i, thickness, points.join(','))
  626.   end
  627.   #-----------------------------------------------------------------------------
  628.   # * Draw Pie
  629.   #     x           : x-coordinate
  630.   #     y           : y-coordinate
  631.   #     width       : width of the shape
  632.   #     height      : height of the shape
  633.   #     start_angle : Angle in degrees measured clockwise from the x-axis to the
  634.   #                   starting point of the arc
  635.   #     sweep_angle : Angle in degrees measured clockwise from the startAngle
  636.   #                   parameter to ending point of the arc
  637.   #     color       : Color used to draw
  638.   #     thickness   : Thickness, in pixels, of the pen used to draw
  639.   #-----------------------------------------------------------------------------
  640.   def draw_pie(x, y, width, height, start_angle, sweep_angle, color, thickness)
  641.     DrawPie.call(__id__, x, y, width, height, start_angle, sweep_angle,
  642.       color.to_i, thickness)
  643.   end
  644.   #-----------------------------------------------------------------------------
  645.   # * Fill Closed Curve
  646.   #     color   : Color used to draw
  647.   #     tension : Specifies the tension of the curve
  648.   #     points  : Points used to draw shape, variable number of arguments.
  649.   #-----------------------------------------------------------------------------
  650.   def fill_closed_curve(color, *points)
  651.     FillClosedCurve.call(__id__, color.to_i, tension.to_s, points.join(','))
  652.   end
  653.   #-----------------------------------------------------------------------------
  654.   # * Fill Ellipse
  655.   #     color     : Color used to draw
  656.   #     x         : x-coordinate
  657.   #     y         : y-coordinate
  658.   #     width     : width of the shape
  659.   #     height    : height of the shape
  660.   #-----------------------------------------------------------------------------
  661.   def fill_ellipse(x, y, width, height, color)
  662.     FillEllipse.call(__id__, color.to_i, x, y, width, height)
  663.   end
  664.   #-----------------------------------------------------------------------------
  665.   # * Fill Pie
  666.   #     color       : Color used to draw
  667.   #     x           : x-coordinate
  668.   #     y           : y-coordinate
  669.   #     width       : width of the shape
  670.   #     height      : height of the shape
  671.   #     start_angle : Angle in degrees measured clockwise from the x-axis to the
  672.   #                   starting point of the arc
  673.   #     sweep_angle : Angle in degrees measured clockwise from the startAngle
  674.   #                   parameter to ending point of the arc
  675.   #-----------------------------------------------------------------------------
  676.   def fill_pie(color, x, y, width, height, start_angle, sweep_angle)
  677.     FillPie.call(__id__, color.to_i, x, y, width, height, start_angle, sweep_angle)
  678.   end
  679.   #-----------------------------------------------------------------------------
  680.   # * Fill Polygon
  681.   #     color   : Color used to draw
  682.   #     points  : Points used to draw shape, variable number of arguments.
  683.   #-----------------------------------------------------------------------------
  684.   def fill_polygon(color, *points)  
  685.     FillPolygon.call(__id__, color.to_i, points.join(','))
  686.   end
  687.   #-----------------------------------------------------------------------------
  688.   # * Fill Rectangle Gradient
  689.   #     x      : x-coordinate
  690.   #     y      : y-coordinate
  691.   #     width  : width of the shape
  692.   #     height : height of the shape
  693.   #     color1 : Start color used to draw the gradient
  694.   #     color2 : End color used to draw the gradient
  695.   #     angle  : Angle at which the gradient will be drawn across the shape
  696.   #-----------------------------------------------------------------------------
  697.   def fill_gradient_rect(x, y, width, height, color1, color2, angle)
  698.     FillGradientRect.call(__id__, x, y, width, height, color1.to_i,
  699.       color2.to_i, angle.to_s)
  700.   end
  701.   #-----------------------------------------------------------------------------
  702.   # * Fill Ellipse Gradient
  703.   #     x      : x-coordinate
  704.   #     y      : y-coordinate
  705.   #     width  : width of the shape
  706.   #     height : height of the shape
  707.   #     color1 : Start color used to draw the gradient
  708.   #     color2 : End color used to draw the gradient
  709.   #     angle  : Angle at which the gradient will be drawn across the shape
  710.   #-----------------------------------------------------------------------------
  711.   def fill_gradient_ellipse(x, y, width, height, color1, color2, angle)
  712.     FillGradientEllipse.call(__id__, x, y, width, height, color1.to_i,
  713.       color2.to_i, angle.to_s)
  714.   end
  715.   #-----------------------------------------------------------------------------
  716.   # * Fill Polygon  Gradient
  717.   #     color1 : Start color used to draw the gradient
  718.   #     color2 : End color used to draw the gradient
  719.   #     angle  : Angle at which the gradient will be drawn across the shape
  720.   #     points : Points used to draw shape, variable number of arguments.
  721.   #-----------------------------------------------------------------------------
  722.   def fill_gradient_polygon(color1, color2, angle, *points)  
  723.     FillGradientPolygon.call(__id__, color1.to_i, color2.to_i,
  724.       angle.to_s, points.join(','))
  725.   end
  726.   #-----------------------------------------------------------------------------
  727.   # * Invert Colors (Destructive)
  728.   #     invert_alpha : Flag indiciating if the alpha component will be inverted
  729.   #-----------------------------------------------------------------------------
  730.   def invert!(invert_alpha = false)
  731.     Invert.call(__id__, invert_alpha ? 1 : 0)
  732.   end
  733.   #-----------------------------------------------------------------------------
  734.   # * Invert Colors (Non-Destructive)
  735.   #     invert_alpha : Flag indiciating if the alpha component will be inverted
  736.   #-----------------------------------------------------------------------------
  737.   def invert(invert_alpha = false)
  738.     bitmap = self.clone
  739.     Invert.call(bitmap.__id__, invert_alpha ? 1 : 0)
  740.     return bitmap
  741.   end
  742.   #-----------------------------------------------------------------------------
  743.   # * Pixelate (Destructive)
  744.   #     amount : New size of pixels in the bitmap
  745.   #     alpha  : Flag indicating if alpha will be averaged into pixel colors
  746.   #-----------------------------------------------------------------------------
  747.   def pixelate!(amount = 4, alpha = false)
  748.     amount = [[amount, 2].max, self.width / 2].min
  749.     Pixelate.call(__id__, amount, alpha ? 1 : 0)
  750.   end
  751.   #-----------------------------------------------------------------------------
  752.   # * Pixelate (Non-Destructive)
  753.   #     amount : New size of pixels in the bitmap
  754.   #     alpha  : Flag indicating if alpha will be averaged into pixel colors
  755.   #-----------------------------------------------------------------------------
  756.   def pixelate(amount = 4, alpha = false)
  757.     bitmap = self.clone
  758.     amount = [[amount, 2].max, self.width / 2].min
  759.     Pixelate.call(bitmap.__id__, amount, alpha ? 1 : 0)
  760.     return bitmap
  761.   end
  762.   #-----------------------------------------------------------------------------
  763.   # * Change Color Component (Destructive)
  764.   #     amount          : Amount to change color component (-255..255)
  765.   #     color_component : Component to change (B:0, G:1, R:2, A:3)
  766.   #-----------------------------------------------------------------------------
  767.   def change_rgba!(amount, color_component)
  768.     ChangeRgba.call(__id__, amount, color_component)
  769.   end
  770.   #-----------------------------------------------------------------------------
  771.   # * Change Color Component (Non-Destructive)
  772.   #     amount          : Amount to change color component (-255..255)
  773.   #     color_component : Component to change (B:0, G:1, R:2, A:3)
  774.   #-----------------------------------------------------------------------------
  775.   def change_rgba(amount, color_component)
  776.     bitmap = self.clone
  777.     ChangeRgba.call(bitmap.__id__, amount, color_component)
  778.     return bitmap
  779.   end
  780.   #-----------------------------------------------------------------------------
  781.   # * Gaussian Blur (Destructive)
  782.   #     kernel_size :
  783.   #     weight      :
  784.   #-----------------------------------------------------------------------------
  785.   def gaussian_blur!(kernel_size = 5, weight = 5.5)
  786.     GaussianBlur.call(__id__, kernel_size, weight.to_s)
  787.   end
  788.   #-----------------------------------------------------------------------------
  789.   # * Gaussian Blur (Non-Destructive)
  790.   #     kernel_size :
  791.   #     weight      :
  792.   #-----------------------------------------------------------------------------
  793.   def gaussian_blur(kernel_size = 5, weight = 5.5)
  794.     bitmap = self.clone
  795.     GaussianBlur.call(bitmap.__id__, kernel_size, weight.to_s)
  796.     return bitmap
  797.   end
  798.   #-----------------------------------------------------------------------------
  799.   # * Blur Effect (Destructive)
  800.   #     type   : Blur algorithm that will be used.
  801.   #              0 : Standard (3x3 matrix, 1.0 factor)
  802.   #              1 : 5x5 Matrix, 1.0 / 13.0 factor)
  803.   #              2 : Gaussian (3x3 matrix, 1.0 / 16.0 factor)
  804.   #              3 : Gaussian (5x5 matrix, 1.0 / 159.0 factor)
  805.   #              4 : Motion (9x9 matrix, 1.0 / 18.0 factor)
  806.   #              5 : Left to Right Motion (9x9 matrix, 1.0 / 9.0 factor)
  807.   #              6 : Right to Left Motion (9x9 matrix, 1.0 / 9.0 factor)
  808.   #              7 : Custom (5x5 matrix, custom factor)
  809.   #     factor : Factor level for custom type. Ignored for all others.
  810.   #-----------------------------------------------------------------------------
  811.   def blur!(type = 0, factor = 1.0)
  812.     Blur.call(__id__, type, factor.to_s)
  813.   end
  814.   #-----------------------------------------------------------------------------
  815.   # * Blur Effect (Non-Destructive)
  816.   #     type   : Blur algorithm that will be used.
  817.   #              0 : Standard (3x3 matrix, 1.0 factor)
  818.   #              1 : 5x5 Matrix, 1.0 / 13.0 factor)
  819.   #              2 : Gaussian (3x3 matrix, 1.0 / 16.0 factor)
  820.   #              3 : Gaussian (5x5 matrix, 1.0 / 159.0 factor)
  821.   #              4 : Motion (9x9 matrix, 1.0 / 18.0 factor)
  822.   #              5 : Left to Right Motion (9x9 matrix, 1.0 / 9.0 factor)
  823.   #              6 : Right to Left Motion (9x9 matrix, 1.0 / 9.0 factor)
  824.   #              7 : Custom (5x5 matrix, custom factor)
  825.   #     factor : Factor level for custom type. Ignored for all others.
  826.   #-----------------------------------------------------------------------------
  827.   def blur(type = 0, factor = 1.0)
  828.     bitmap = self.clone
  829.     Blur.call(__id__, type, factor.to_s)
  830.     return bitmap
  831.   end
  832.   #-----------------------------------------------------------------------------
  833.   # * Sharpen (Destructive)
  834.   #     type   : Sharpen algorithm that will be used.
  835.   #              0 : Standard (1.0 factor)
  836.   #              1 : Light (3x3 matrix)
  837.   #              2 : Ultra-Light (3x3 matrix, 0.3 factor)
  838.   #              3 : 5x5 matrix (Depending on source, sometimes softens)
  839.   #              4 : Intense
  840.   #              5 : Custom defined factor will be used
  841.   #     factor : Factor level for custom type. Ignored for all others.
  842.   #-----------------------------------------------------------------------------
  843.   def sharpen!(type = 0, factor = 1.0)
  844.     Sharpen.call(__id__, type, factor.to_s)
  845.   end
  846.   #-----------------------------------------------------------------------------
  847.   # * Sharpen (Non-Destructive)
  848.   #     type   : Sharpen algorithm that will be used.
  849.   #              0 : Standard (1.0 factor)
  850.   #              1 : Light (3x3 matrix)
  851.   #              2 : Ultra-Light (3x3 matrix, 0.3 factor)
  852.   #              3 : 5x5 matrix (Depending on source, sometimes softens)
  853.   #              4 : Intense
  854.   #              5 : Custom defined factor will be used
  855.   #     factor : Factor level for custom type. Ignored for all others.
  856.   #-----------------------------------------------------------------------------
  857.   def sharpen(type = 0, factor = 1.0)
  858.     bitmap = self.clone
  859.     Sharpen.call(bitmap.__id__, type, factor.to_s)
  860.     return bitmap
  861.   end
  862.   #-----------------------------------------------------------------------------
  863.   # * Soften (Destructive)
  864.   #-----------------------------------------------------------------------------
  865.   def soften!
  866.     Soften.call(__id__)
  867.   end
  868.   #-----------------------------------------------------------------------------
  869.   # * Soften (Non-Destructive)
  870.   #-----------------------------------------------------------------------------
  871.   def soften
  872.     bitmap = self.clone
  873.     Soften.call(bitmap.__id__)
  874.     return bitmap
  875.   end
  876.   #-----------------------------------------------------------------------------
  877.   # * Edge Detect (Destructive)
  878.   #     type      : Edge-detection algorithm that will be used.
  879.   #                 0 = Standard
  880.   #                 1 = 45 Degree
  881.   #                 2 = Horizontal
  882.   #                 3 = Vertical
  883.   #     grayscale : Flag indicating if result will be grayscaled
  884.   #-----------------------------------------------------------------------------
  885.   def edge_detect!(type = 0, grayscale = false)
  886.     EdgeDetect.call(__id__, type, grayscale ? 1 : 0)
  887.   end
  888.   #-----------------------------------------------------------------------------
  889.   # * Edge Detect (Non-Destructive)
  890.   #     type      : Edge-detection algorithm that will be used.
  891.   #                 0 = Standard
  892.   #                 1 = 45 Degree
  893.   #                 2 = Horizontal
  894.   #                 3 = Vertical
  895.   #     grayscale : Flag indicating if result will be grayscaled
  896.   #-----------------------------------------------------------------------------
  897.   def edge_detect(type = 0, grayscale = false)
  898.     bitmap = self.clone
  899.     EdgeDetect.call(bitmap.__id__, type, grayscale ? 1 : 0)
  900.     return bitmap
  901.   end
  902.   #-----------------------------------------------------------------------------
  903.   # * Poster Effect (Destructive)
  904.   #-----------------------------------------------------------------------------
  905.   def poster_effect!
  906.     PosterEffect.call(__id__)
  907.   end
  908.   #-----------------------------------------------------------------------------
  909.   # * Poster Effect (Non-Destructive)
  910.   #-----------------------------------------------------------------------------
  911.   def poster_effect
  912.     bitmap = self.clone
  913.     PosterEffect.call(bitmap.__id__)
  914.     return bitmap
  915.   end
  916.   #-----------------------------------------------------------------------------
  917.   # * High Pass Filter (Destructive)
  918.   #-----------------------------------------------------------------------------
  919.   def high_pass!(grayscale = false)
  920.     HighPass.call(__id__, grayscale ? 1 : 0)
  921.   end
  922.   #-----------------------------------------------------------------------------
  923.   # * High Pass Filter (Non-Destructive)
  924.   #-----------------------------------------------------------------------------
  925.   def high_pass(grayscale = false)
  926.     bitmap = self.clone
  927.     HighPass.call(bitmap.__id__, grayscale ? 1 : 0)
  928.     return bitmap
  929.   end
  930.   #-----------------------------------------------------------------------------
  931.   # * Color Mask
  932.   #     color     : Color to create mask for
  933.   #     tolerance : Amount of variance allowed in pixel comparison.
  934.   #-----------------------------------------------------------------------------
  935.   def color_mask(color, tolerance)
  936.     mask = self.clone
  937.     ColorMask.call(mask.__id__, color.to_i, tolerance)
  938.     return mask
  939.   end
  940.   #-----------------------------------------------------------------------------
  941.   # * Sepia Effect (Destructive)
  942.   #-----------------------------------------------------------------------------
  943.   def sepia!
  944.     Sepia.call(__id__)
  945.   end
  946.   #-----------------------------------------------------------------------------
  947.   # * Sepia Effect (Non-Destructive)
  948.   #-----------------------------------------------------------------------------
  949.   def sepia
  950.     bitmap = self.clone
  951.     Sepia.call(bitmap.__id__)
  952.     return bitmap
  953.   end
  954.   #-----------------------------------------------------------------------------
  955.   # * Grayscale Effect (Destructive)
  956.   #     remove_alpha : Flag indicating if alpha component will be removed
  957.   #-----------------------------------------------------------------------------
  958.   def grayscale!(remove_alpha = false)
  959.     Grayscale.call(__id__, remove_alpha ? 1 : 0)
  960.   end
  961.   #-----------------------------------------------------------------------------
  962.   # * Grayscale Effect (Non-Destructive)
  963.   #     remove_alpha : Flag indicating if alpha component will be removed
  964.   #-----------------------------------------------------------------------------
  965.   def grayscale(remove_alpha = false)
  966.     bitmap = self.clone
  967.     Grayscale.call(bitmap.__id__, remove_alpha ? 1 : 0)
  968.     return bitmap
  969.   end
  970.   #-----------------------------------------------------------------------------
  971.   # * Emboss Effect (Destructive)
  972.   #     type      : Emboss algorithm that will be used.
  973.   #                 0 : Standard
  974.   #                 1 : 45 Degree
  975.   #                 2 : Top-Left Bottom-Right
  976.   #                 3 : Intense
  977.   #     grayscale : Flag indicating if result will be grayscaled
  978.   #-----------------------------------------------------------------------------
  979.   def emboss!(type = 0, grayscale = false)
  980.     Emboss.call(__id__, type, grayscale ? 1 : 0)
  981.   end
  982.   #-----------------------------------------------------------------------------
  983.   # * Emboss Effect (Non-Destructive)
  984.   #     type      : Emboss algorithm that will be used.
  985.   #                 0 : Standard
  986.   #                 1 : 45 Degree
  987.   #                 2 : Top-Left Bottom-Right
  988.   #                 3 : Intense
  989.   #     grayscale : Flag indicating if result will be grayscaled
  990.   #-----------------------------------------------------------------------------
  991.   def emboss(type = 0, grayscale = false)
  992.     bitmap = self.clone
  993.     Emboss.call(bitmap.__id__, type, grayscale ? 1 : 0)
  994.     return bitmap
  995.   end
  996.   #-----------------------------------------------------------------------------
  997.   # * Tint Bitmap Colors (Destructive)
  998.   #     red_percent   : Percentage of red to increase. (0 - 100)
  999.   #     green_percent : Percentage of green to increase. (0 - 100)
  1000.   #     blue_percent  : Percentage of blue to increase. (0 - 100)
  1001.   #-----------------------------------------------------------------------------
  1002.   def tint!(red_percent, green_percent, blue_percent)
  1003.     Tint.call(__id__, red_percent, green_percent, blue_percent)
  1004.   end
  1005.   #-----------------------------------------------------------------------------
  1006.   # * Tint Bitmap Colors (Non-Destructive)
  1007.   #     red_percent   : Percentage of red to increase. (0 - 100)
  1008.   #     green_percent : Percentage of green to increase. (0 - 100)
  1009.   #     blue_percent  : Percentage of blue to increase. (0 - 100)
  1010.   #-----------------------------------------------------------------------------
  1011.   def tint(red_percent, green_percent, blue_percent)
  1012.     bitmap = self.clone
  1013.     Tint.call(bitmap.__id__, red_percent, green_percent, blue_percent)
  1014.     return bitmap
  1015.   end
  1016.   #-----------------------------------------------------------------------------
  1017.   # * Bitmap Color Balance (Destructive)
  1018.   #     red   : Red balance component (0 - 255)
  1019.   #     green : Green balance component (0 - 255)
  1020.   #     blue  : Blue balance component (0 - 255)
  1021.   #-----------------------------------------------------------------------------
  1022.   def color_balance!(red, green, blue)
  1023.     ColorBalance.call(__id__, red, green, blue)
  1024.   end
  1025.   #-----------------------------------------------------------------------------
  1026.   # * Bitmap Color Balance (Non-Destructive)
  1027.   #     red   : Red balance component (0 - 255)
  1028.   #     green : Green balance component (0 - 255)
  1029.   #     blue  : Blue balance component (0 - 255)
  1030.   #-----------------------------------------------------------------------------
  1031.   def color_balance(red, green, blue)
  1032.     bitmap = self.clone
  1033.     ColorBalance.call(bitmap.__id__, red, green, blue)
  1034.     return bitmap
  1035.   end
  1036.   #-----------------------------------------------------------------------------
  1037.   # * Bitonal Bitmap (Destructive)
  1038.   #     dark_color  : Color used for dark tones below the threshold
  1039.   #     light_color : Color used for light tones above the threshold
  1040.   #     threshold   : Threshold to determine light tones from dark tones
  1041.   #-----------------------------------------------------------------------------
  1042.   def bitonal!(dark_color, light_color, threshold)
  1043.     Bitonal.call(__id__, dark_color.to_i, light_color.to_i, threshold)
  1044.   end
  1045.   #-----------------------------------------------------------------------------
  1046.   # * Bitonal Bitmap (Non-Destructive)
  1047.   #     dark_color  : Color used for dark tones below the threshold
  1048.   #     light_color : Color used for light tones above the threshold
  1049.   #     threshold   : Threshold to determine light tones from dark tones
  1050.   #-----------------------------------------------------------------------------
  1051.   def bitonal(dark_color, light_color, threshold)
  1052.     bitmap = self.clone
  1053.     Bitonal.call(bitmap.__id__, dark_color.to_i, light_color.to_i, threshold)
  1054.     return bitmap
  1055.   end
  1056.   #-----------------------------------------------------------------------------
  1057.   # * Apply Solarise Effect (Destructive)
  1058.   #     red   : Red threshold value (0 - 255)
  1059.   #     green : Green threshold value (0 - 255)
  1060.   #     blue  : Blue threshold value (0 - 255)
  1061.   #-----------------------------------------------------------------------------
  1062.   def solarise!(red, green, blue)
  1063.     Solarise.call(__id__, red, green, blue)
  1064.   end
  1065.   #-----------------------------------------------------------------------------
  1066.   # * Apply Solarise Effect (Non-Destructive)
  1067.   #     red   : Red threshold value (0 - 255)
  1068.   #     green : Green threshold value (0 - 255)
  1069.   #     blue  : Blue threshold value (0 - 255)
  1070.   #-----------------------------------------------------------------------------
  1071.   def solarise(red, green, blue)
  1072.     bitmap = self.clone
  1073.     Solarise.call(bitmap.__id__, red, green, blue)
  1074.     return bitmap
  1075.   end
  1076.   #-----------------------------------------------------------------------------
  1077.   # * Median Filter Effect (Destructive)
  1078.   #     matrix_size : Size of the matrix used to calculate pixels
  1079.   #     bias        : Amount of bias to apply to the colors
  1080.   #     grayscale   : Flag indicating if result will be grayscaled
  1081.   #-----------------------------------------------------------------------------
  1082.   def median_filter!(matrix_size = 3, bias = 0, grayscale = false)
  1083.     MedianFilter.call(__id__, matrix_size, bias, grayscale ? 1 : 0)
  1084.   end
  1085.   #-----------------------------------------------------------------------------
  1086.   # * Median Filter Effect (Non-Destructive)
  1087.   #     matrix_size : Size of the matrix used to calculate pixels
  1088.   #     bias        : Amount of bias to apply to the colors
  1089.   #     grayscale   : Flag indicating if result will be grayscaled
  1090.   #-----------------------------------------------------------------------------
  1091.   def median_filter(matrix_size = 3, bias = 0, grayscale = false)
  1092.     bitmap = self.clone
  1093.     MedianFilter.call(bitmap.__id__, matrix_size, bias, grayscale ? 1 : 0)
  1094.     return bitmap
  1095.   end
  1096.   #-----------------------------------------------------------------------------
  1097.   # * Rotate and/or Flip Bitmap (Destructive)
  1098.   #     type : 0: Rotate180FlipXY or RotateNoneFlipNone
  1099.   #            1: Rotate270FlipXY or Rotate90FlipNone
  1100.   #            2: RotateNoneFlipXY or Rotate180FlipNone
  1101.   #            3: Rotate90FlipXY or Rotate270FlipNone
  1102.   #            4: Rotate180FlipY or RotateNoneFlipX
  1103.   #            5: Rotate90FlipX or Rotate270FlipY
  1104.   #            6: RotateNoneFlipY or Rotate180FlipX
  1105.   #            7: Rotate90FlipY or Rotate270FlipX
  1106.   #-----------------------------------------------------------------------------
  1107.   def rotate_flip!(type)
  1108.     RotateFlip.call(__id__, type)
  1109.   end
  1110.   #-----------------------------------------------------------------------------
  1111.   # * Rotate and/or Flip Bitmap (Non-Destructive)
  1112.   #     type : 0: Rotate180FlipXY or RotateNoneFlipNone
  1113.   #            1: Rotate270FlipXY or Rotate90FlipNone
  1114.   #            2: RotateNoneFlipXY or Rotate180FlipNone
  1115.   #            3: Rotate90FlipXY or Rotate270FlipNone
  1116.   #            4: Rotate180FlipY or RotateNoneFlipX
  1117.   #            5: Rotate90FlipX or Rotate270FlipY
  1118.   #            6: RotateNoneFlipY or Rotate180FlipX
  1119.   #            7: Rotate90FlipY or Rotate270FlipX
  1120.   #-----------------------------------------------------------------------------
  1121.   def rotate_flip(type)
  1122.     bitmap = self.clone
  1123.     RotateFlip.call(bitmap.__id__, type)
  1124.     return bitmap
  1125.   end
  1126. end
  1127.  
  1128. #===============================================================================
  1129. # ** Graphics
  1130. #-------------------------------------------------------------------------------
  1131. # The module that carries out graphics processing.
  1132. #===============================================================================
  1133.  
  1134. module Graphics
  1135.   #-----------------------------------------------------------------------------
  1136.   # * Width of window client area
  1137.   #-----------------------------------------------------------------------------
  1138.   def self.width
  1139.     return RpgNET.get_window_rect.width
  1140.   end
  1141.   #-----------------------------------------------------------------------------
  1142.   # * Height of window client area
  1143.   #-----------------------------------------------------------------------------
  1144.   def self.height
  1145.     return RpgNET.get_window_rect.height
  1146.   end
  1147. end
  1148.  
  1149. #===============================================================================
  1150. # ** Sprite
  1151. #-------------------------------------------------------------------------------
  1152. # Sprites are the basic concept used to display on the game screen.
  1153. #===============================================================================
  1154.  
  1155. class Sprite
  1156.   #-----------------------------------------------------------------------------
  1157.   # * Constants
  1158.   #-----------------------------------------------------------------------------
  1159.   CreateEffect = Win32API.new(RPGNET, 'CreateSpriteEffect', 'iiip', '')
  1160.   UpdateEffect = Win32API.new(RPGNET, 'UpdateSpriteEffect', 'ii', '')
  1161.   #-----------------------------------------------------------------------------
  1162.   # * Shrink
  1163.   #     frames : Number of frames effect will last
  1164.   #-----------------------------------------------------------------------------
  1165.   def shrink(frames = 20)
  1166.     return if @effect_frame != nil
  1167.     self.bitmap = self.bitmap.clone
  1168.     @effect_frame = frames
  1169.     CreateEffect.call(self.bitmap.__id__, 1, frames, '')
  1170.   end
  1171.   #-----------------------------------------------------------------------------
  1172.   # * Hue Rotation
  1173.   #     frames : Number of frames effect will last
  1174.   #     speed  : Amount of hue change each step
  1175.   #     fade   : Flag indicating if sprite will fade out
  1176.   #-----------------------------------------------------------------------------
  1177.   def hue_effect(frames = 60, speed = 8, fade = false)
  1178.     return if @effect_frame != nil
  1179.     self.bitmap = self.bitmap.clone
  1180.     @effect_frame = frames
  1181.     CreateEffect.call(self.bitmap.__id__, 2, frames, [speed, fade].join(','))
  1182.   end
  1183.   #-----------------------------------------------------------------------------
  1184.   # * Flatten
  1185.   #     frames     : Number of frames effect will last
  1186.   #     direction  : Direction of effect, 0:Up, 1:Down
  1187.   #-----------------------------------------------------------------------------
  1188.   def flatten(frames = 10, direction = 0)
  1189.     return if @effect_frame != nil
  1190.     self.bitmap = self.bitmap.clone
  1191.     @effect_frame = frames
  1192.     CreateEffect.call(self.bitmap.__id__, 3, frames, direction.to_s)
  1193.   end
  1194.   #-----------------------------------------------------------------------------
  1195.   # * Flatten
  1196.   #     frames     : Number of frames effect will last
  1197.   #     direction  : Direction of effect, 0:Horizontal, 1:Vertical
  1198.   #-----------------------------------------------------------------------------
  1199.   def squeeze(frames = 5, direction = 0)
  1200.     return if @effect_frame != nil
  1201.     self.bitmap = self.bitmap.clone
  1202.     @effect_frame = frames
  1203.     CreateEffect.call(self.bitmap.__id__, 4, frames, direction.to_s)
  1204.   end
  1205.   #-----------------------------------------------------------------------------
  1206.   # * Frame Update
  1207.   #-----------------------------------------------------------------------------
  1208.   alias rpgnet_update update
  1209.   def update
  1210.     rpgnet_update
  1211.     if @effect_frame != nil
  1212.       UpdateEffect.call(self.bitmap.__id__, @effect_frame)
  1213.       @effect_frame -= 1
  1214.       if @effect_frame < 0
  1215.         @effect_frame = nil
  1216.       end
  1217.     end
  1218.   end
  1219. end
  1220.  
  1221. #===============================================================================
  1222. # ** Color
  1223. #-------------------------------------------------------------------------------
  1224. # The RGBA color class. Each component is handled with a floating point value.
  1225. #===============================================================================
  1226.  
  1227. class Color
  1228.   #-----------------------------------------------------------------------------
  1229.   # * Integer value of Color
  1230.   #-----------------------------------------------------------------------------
  1231.   def to_i
  1232.     string = [red.to_i.chr, green.to_i.chr, blue.to_i.chr, alpha.to_i.chr].join
  1233.     return string.unpack('L').shift
  1234.   end
  1235. end
  1236.  
  1237. #===============================================================================
  1238. # ** Gradient
  1239. #-------------------------------------------------------------------------------
  1240. # Represents a gradient color
  1241. #===============================================================================
  1242. Gradient = Struct.new(:color1, :color2, :angle)
  1243.  
  1244. #===============================================================================
  1245. # ** Gradient
  1246. #-------------------------------------------------------------------------------
  1247. # The font class. Font is a property of the Bitmap class.
  1248. #===============================================================================
  1249. class Font
  1250.   attr_accessor :gradient
  1251. end
  1252.  
  1253. #===============================================================================
  1254. # ** RPG::AudioFile
  1255. #-------------------------------------------------------------------------------
  1256. # Data class for audio files. Common to all formats (BGM, BGS, ME, SE).
  1257. #===============================================================================
  1258.  
  1259. class RPG::AudioFile
  1260.   #-----------------------------------------------------------------------------
  1261.   # * Duration in Milliseconds
  1262.   #-----------------------------------------------------------------------------
  1263.   def milliseconds
  1264.     dir = File.dirname(@name)
  1265.     filename = File.basename(@name)
  1266.     path = RpgNET.get_full_path(filename, dir)
  1267.     return Audio::GetAudioDurationMs.call(path)
  1268.   end
  1269.   #-----------------------------------------------------------------------------
  1270.   # * Duration in Frames
  1271.   #     frame_rate : Frame rate to calculate number of frames for.
  1272.   #-----------------------------------------------------------------------------
  1273.   def frame_duration(frame_rate)
  1274.     return milliseconds / frame_rate
  1275.   end
  1276. end
  1277.  
  1278. #===============================================================================
  1279. # ** Vector
  1280. #-------------------------------------------------------------------------------
  1281. # This struct represents magnitude (length) and direction.
  1282. #===============================================================================
  1283. Vector = Struct.new(:x, :y, :z)
  1284.  
  1285. #===============================================================================
  1286. # ** ParticleGenerator
  1287. #-------------------------------------------------------------------------------
  1288. # This class acts as a wrapper around an Rpg.NET ParticleGenerator.
  1289. #===============================================================================
  1290.  
  1291. class ParticleGenerator < Sprite
  1292.   #-----------------------------------------------------------------------------
  1293.   # * Particle Types
  1294.   #-----------------------------------------------------------------------------
  1295.   FOUNTAIN  = 0x01
  1296.   FIREWORK  = 0x02
  1297.   EXPLOSION = 0x03
  1298.   #-----------------------------------------------------------------------------
  1299.   # * Constants
  1300.   #-----------------------------------------------------------------------------
  1301.   Initialize = Win32API.new(RPGNET, 'PgInitialize', 'ii', '')
  1302.   SetEnabled = Win32API.new(RPGNET, 'PgSetEnabled', 'ii', '')
  1303.   SetEnvironment = Win32API.new(RPGNET, 'PgSetEnvironment', 'ipp', '')
  1304.   SetSpeed = Win32API.new(RPGNET, 'PgSetSpeed', 'ii', '')
  1305.   SetParticles = Win32API.new(RPGNET, 'PgSetParticles', 'iii', '')
  1306.   SetColors = Win32API.new(RPGNET, 'PgSetColors', 'ip', '')
  1307.   GetRegenerate = Win32API.new(RPGNET, 'PgGetRegenerate', 'i', '')
  1308.   SetRegenerate = Win32API.new(RPGNET, 'PgSetRegenerate', 'ii', '')
  1309.   Dispose = Win32API.new(RPGNET, 'PgDispose', 'i', '')
  1310.   #-----------------------------------------------------------------------------
  1311.   # * Public Instance Variables
  1312.   #-----------------------------------------------------------------------------
  1313.   attr_reader :enabled
  1314.   attr_reader :gravity
  1315.   attr_reader :wind
  1316.   attr_reader :max_particles
  1317.   attr_reader :life_span
  1318.   attr_reader :type
  1319.   attr_reader :colors
  1320.   #-----------------------------------------------------------------------------
  1321.   # * Object Initialization
  1322.   #-----------------------------------------------------------------------------
  1323.   def initialize(viewport, width, height, type)
  1324.     super(viewport)
  1325.     self.bitmap = Bitmap.new(width, height)
  1326.     @id = self.bitmap.__id__
  1327.     @type = type
  1328.     @wind = Vector.new(0.002, 0.0, 0.0)
  1329.     @gravity = Vector.new(0.0, -0.02, 0.0)
  1330.     @speed = 20
  1331.     @life_span = 150
  1332.     @max_particles = 250
  1333.     Initialize.call(@id, @type)
  1334.   end
  1335.   #-----------------------------------------------------------------------------
  1336.   # * Width of the Particle Generator
  1337.   #-----------------------------------------------------------------------------
  1338.   def width
  1339.     return self.bitmap.width
  1340.   end
  1341.   #-----------------------------------------------------------------------------
  1342.   # * Height of the Particle Generator
  1343.   #-----------------------------------------------------------------------------
  1344.   def height
  1345.     return self.bitmap.height
  1346.   end
  1347.   #-----------------------------------------------------------------------------
  1348.   # * Start/Stop Particle Generation
  1349.   #     value : Flag indicating if generator is enabled or not
  1350.   #-----------------------------------------------------------------------------
  1351.   def enabled=(value)
  1352.     if @enabled != value
  1353.       @enabled = value
  1354.       SetEnabled.call(@id, @enabled ? 1 : 0)
  1355.     end
  1356.   end
  1357.   #-----------------------------------------------------------------------------
  1358.   # * Get Regenerate Flag
  1359.   #-----------------------------------------------------------------------------
  1360.   def regenerate
  1361.     return GetRegenerate.call(@id)
  1362.   end
  1363.   #-----------------------------------------------------------------------------
  1364.   # * Set Regenerate Flag
  1365.   #     value : Flag indicating if generator regenerates after executing
  1366.   #-----------------------------------------------------------------------------
  1367.   def regenerate=(value)
  1368.     SetRegenerate.call(@id, value ? 1 : 0)
  1369.   end
  1370.   #-----------------------------------------------------------------------------
  1371.   # * Set Particle Environment
  1372.   #     wind    : Vector representing wind factor
  1373.   #     gravity : Vector representing gravity factor
  1374.   #-----------------------------------------------------------------------------
  1375.   def set_environment(wind, gravity)
  1376.     if (@wind != wind) || (@gravity != gravity)
  1377.       @wind = wind
  1378.       @gravity = gravity
  1379.       wind = [@wind.x, @wind.y, @wind.z].join(',')
  1380.       gravity = [@gravity.x, @gravity.y, @gravity.z].join(',')
  1381.       SetEnvironment.call(@id, wind, gravity)
  1382.     end
  1383.   end
  1384.   #-----------------------------------------------------------------------------
  1385.   # * Set Particle Generator Speed
  1386.   #     value : Speed, in milliseconds, between updates
  1387.   #-----------------------------------------------------------------------------
  1388.   def speed=(value)
  1389.     if @speed != speed
  1390.       @speed = [speed, 4].max
  1391.       SetSpeed.call(@id, @speed)
  1392.     end
  1393.   end
  1394.   #-----------------------------------------------------------------------------
  1395.   # * Set Particle Settings
  1396.   #     max_particles : Maximum number of particles created at one time
  1397.   #     life_span     : Duration of time a particle will last
  1398.   #-----------------------------------------------------------------------------
  1399.   def set_particles(max_particles, life_span)
  1400.     if (@max_particles != max_particles) || (@life_span != life_span)
  1401.       @max_particles = [max_particles, 1].max
  1402.       @life_span = [life_span, 1].max
  1403.       SetParticles.call(@id, @max_particles, @life_span)
  1404.     end
  1405.   end
  1406.   #-----------------------------------------------------------------------------
  1407.   # * Dispose
  1408.   #-----------------------------------------------------------------------------
  1409.   alias base_dispose dispose
  1410.   def dispose
  1411.     Dispose.call(@id)
  1412.     base_dispose
  1413.   end
  1414.   #-----------------------------------------------------------------------------
  1415.   # * Set Color(s) used for Particles
  1416.   #     colors : One or more colors
  1417.   #-----------------------------------------------------------------------------
  1418.   def set_colors(*colors)
  1419.     if @colors != colors
  1420.       @colors = colors
  1421.       if @colors.size == 0
  1422.         @colors.push(Color.new(0, 0, 0, 0))
  1423.       end
  1424.       colors = @colors.collect {|c| c.to_i }
  1425.       SetColors.call(@id, colors.join(','))
  1426.     end
  1427.   end
  1428. end
  1429.  
  1430. #===============================================================================
  1431. # ** Input
  1432. #-------------------------------------------------------------------------------
  1433. # A module that handles input data from a gamepad or keyboard.
  1434. #===============================================================================
  1435.  
  1436. module Input
  1437.   #-----------------------------------------------------------------------------
  1438.   # * Virtual Keys
  1439.   #-----------------------------------------------------------------------------
  1440.         Key = { 'NONE' => 0, 'LBUTTON' => 1, 'RBUTTON' => 2, 'CANCEL' => 3,
  1441.                 'MBUTTON' => 4, 'XBUTTON1' => 5, 'XBUTTON2' => 6, 'BACK' => 8, 'TAB' => 9,
  1442.                 'LINEFEED' => 10, 'CLEAR' => 12, 'RETURN' => 13, 'ENTER' => 13,
  1443.     'SHIFTKEY' => 16, 'CONTROLKEY' => 17, 'MENU' => 18, 'PAUSE' => 19,
  1444.                 'CAPITAL' => 20, 'CAPSLOCK' => 20, 'KANAMODE' => 21, 'HANGULMODE' => 21,
  1445.                 'HANGUELMODE' => 21, 'JUNJAMODE' => 23, 'FINALMODE' => 24,'HANJAMODE' => 25,
  1446.                 'KANJIMODE' => 25, 'ESCAPE' => 27, 'IMECONVERT' => 28,'IMENONCONVERT' => 29,
  1447.                 'IMEACCEPT' => 30, 'IMEMODECHANGE' => 31, 'SPACE' => 32, 'PAGEUP' => 33,
  1448.                 'PRIOR' => 33, 'PAGEDOWN' => 34, 'NEXT' => 34, 'END' => 35, 'HOME' => 36,
  1449.                 'LEFT' => 37, 'UP' => 38, 'RIGHT' => 39, 'DOWN' => 40, 'SELECT' => 41,
  1450.                 'PRINT' => 42, 'EXECUTE' => 43, 'SNAPSHOT' => 44, 'PRINTSCREEN' => 44,
  1451.                 'INSERT' => 45, 'DELETE' => 46, 'HELP' => 47, 'D0' => 48, 'D1' => 49,
  1452.     'D2' => 50, 'D3' => 51, 'D4' => 52, 'D5' => 53, 'D6' => 54, 'D7' => 55,
  1453.                 'D8' => 56, 'D9' => 57, 'A' => 65, 'B' => 66, 'C' => 67, 'D' => 68,
  1454.                 'E' => 69, 'F' => 70, 'G' => 71, 'H' => 72, 'I' => 73, 'J' => 74, 'K' => 75,
  1455.                 'L' => 76, 'M' => 77, 'N' => 78, 'O' => 79, 'P' => 80, 'Q' => 81, 'R' => 82,
  1456.                 'S' => 83, 'T' => 84, 'U' => 85, 'V' => 86, 'W' => 87, 'X' => 88, 'Y' => 89,
  1457.                 'Z' => 90, 'LWIN' => 91, 'RWIN' => 92, 'APPS' => 93, 'SLEEP' => 95,
  1458.                 'NUMPAD0' => 96, 'NUMPAD1' => 97, 'NUMPAD2' => 98, 'NUMPAD3' => 99,
  1459.                 'NUMPAD4' => 100, 'NUMPAD5' => 101, 'NUMPAD6' => 102, 'NUMPAD7' => 103,
  1460.                 'NUMPAD8' => 104, 'NUMPAD9' => 105, 'MULTIPLY' => 106, 'ADD' => 107,
  1461.                 'SEPARATOR' => 108, 'SUBTRACT' => 109, 'DECIMAL' => 110, 'DIVIDE' => 111,
  1462.                 'F1' => 112, 'F2' => 113, 'F3' => 114, 'F4' => 115, 'F5' => 116,'F6' => 117,
  1463.                 'F7' => 118, 'F8' => 119, 'F9' => 120, 'F10' => 121, 'F11' => 122,
  1464.                 'F12' => 123, 'F13' => 124, 'F14' => 125, 'F15' => 126, 'F16' => 127,
  1465.     'F17' => 128, 'F18' => 129, 'F19' => 130, 'F20' => 131, 'F21' => 132,
  1466.                 'F22' => 133, 'F23' => 134, 'F24' => 135, 'NUMLOCK' => 144, 'SCROLL' => 145,
  1467.                 'LSHIFTKEY' => 160, 'RSHIFTKEY' => 161, 'LCONTROLKEY' => 162,
  1468.     'RCONTROLKEY' => 163, 'LMENU' => 164, 'RMENU' => 165, 'BROWSERBACK' => 166,
  1469.                 'BROWSERFORWARD' => 167, 'BROWSERREFRESH' => 168, 'BROWSERSTOP' => 169,
  1470.                 'BROWSERSEARCH' => 170, 'BROWSERFAVORITES' => 171, 'BROWSERHOME' => 172,
  1471.                 'VOLUMEMUTE' => 173, 'VOLUMEDOWN' => 174, 'VOLUMEUP' => 175,
  1472.     'MEDIANEXTTRACK' => 176, 'MEDIAPREVIOUSTRACK' => 177, 'MEDIASTOP' => 178,
  1473.     'MEDIAPLAYPAUSE' => 179, 'LAUNCHMAIL' => 180, 'SELECTMEDIA' => 181,
  1474.                 'LAUNCHAPPLICATION1' => 182, 'LAUNCHAPPLICATION2' => 183, 'OEM_1' => 186,
  1475.                 'OEMSEMICOLON' => 186, 'OEMPLUS' => 187, 'OEMCOMMA' => 188,'OEMMINUS' => 189,
  1476.                 'OEMPERIOD' => 190, 'SLASH' => 191, 'OEM2' => 191, 'OEM3' => 192,
  1477.     'OEMTILDE' => 192, 'LBRACKET' => 219, 'OEM4' => 219, 'OEM5' => 220,
  1478.                 'OEMPIPE' => 220, 'RBRACKET' => 221, 'OEM6' => 221, 'OEM7' => 222,
  1479.                 'OEMQUOTES' => 222, 'OEM8' => 223, 'BACKSLASH' => 226, 'OEM102' => 226,
  1480.                 'PROCESSKEY' => 229, 'PACKET' => 231, 'ATTN' => 246, 'CRSEL' => 247,
  1481.                 'EXSEL' => 248, 'ERASEEOF' => 249, 'PLAY' => 250, 'ZOOM' => 251,
  1482.     'NONAME' => 252, 'PA1' => 253, 'OEMCLEAR' => 254, 'KEYCODE' => 65535,
  1483.                 'SHIFT' => 65536, 'CONTROL' => 131072,'ALT' => 262144, 'MODIFIERS' => -65536
  1484.         }
  1485.   #-----------------------------------------------------------------------------
  1486.   # * Key Configuration
  1487.   #-----------------------------------------------------------------------------
  1488.   UP = [Key['UP']]
  1489.   LEFT = [Key['LEFT']]
  1490.   DOWN = [Key['DOWN']]
  1491.   RIGHT = [Key['RIGHT']]
  1492.   A = [Key['SHIFT']]
  1493.   B = [Key['ESCAPE'], Key['NUMPAD0'], Key['X']]
  1494.   C = [Key['SPACE'], Key['ENTER'], Key['C']]
  1495.   X = [Key['A']]
  1496.   Y = [Key['S']]
  1497.   Z = [Key['D']]
  1498.   L = [Key['Q'], Key['PAGEDOWN']]
  1499.   R = [Key['W'], Key['PAGEUP']]
  1500.   F5 = [Key['F5']]
  1501.   F6 = [Key['F6']]
  1502.   F7 = [Key['F7']]
  1503.   F8 = [Key['F8']]
  1504.   F9 = [Key['F9']]
  1505.   SHIFT = [Key['SHIFT']]
  1506.   CTRL = [Key['CONTROL']]
  1507.   ALT = [Key['ALT']]
  1508.   LMOUSE = [Key['LBUTTON']]
  1509.   RMOUSE = [Key['RBUTTON']]
  1510.   MMOUSE = [Key['MBUTTON']]
  1511.   #-----------------------------------------------------------------------------
  1512.   # * Constants
  1513.   #-----------------------------------------------------------------------------
  1514.   Update = Win32API.new(RPGNET, 'InputUpdate', '', '')
  1515.   IsTriggered = Win32API.new(RPGNET, 'InputIsTriggered', 'i', 'i')
  1516.   IsPressed = Win32API.new(RPGNET, 'InputIsPressed', 'i', 'i')
  1517.   IsRepeated = Win32API.new(RPGNET, 'InputIsRepeated', 'i', 'i')
  1518.   IsReleased = Win32API.new(RPGNET, 'InputIsReleased', 'i', 'i')
  1519.   BeginCapture = Win32API.new(RPGNET, 'InputBeginCapture', '', '')
  1520.   EndCapture = Win32API.new(RPGNET, 'InputEndCapture', '', 'p')
  1521.   MousePosition = Win32API.new(RPGNET, 'InputMousePosition', 'p', '')
  1522.   IsDoubleClick = Win32API.new(RPGNET, 'InputIsDoubleClick', 'i', 'i')
  1523.   IsMouseMoving = Win32API.new(RPGNET, 'InputIsMouseMoved', '', 'i')
  1524.   IsWheelMoved = Win32API.new(RPGNET, 'InputIsWheelMoved', '', 'i')
  1525.   GetWheelDelta = Win32API.new(RPGNET, 'InputGetWheelDelta', '', 'i')
  1526.   #-----------------------------------------------------------------------------
  1527.   # * Frame Update
  1528.   #-----------------------------------------------------------------------------
  1529.   def self.update
  1530.     Update.call
  1531.   end
  1532.   #-----------------------------------------------------------------------------
  1533.   # * Key Triggered
  1534.   #     key : Key constant to test
  1535.   #-----------------------------------------------------------------------------
  1536.   def self.trigger?(key)
  1537.     return IsTriggered.call(key) if key.is_a?(Fixnum)
  1538.     return key.any? {|k| IsTriggered.call(k) != 0 }
  1539.   end
  1540.   #-----------------------------------------------------------------------------
  1541.   # * Key Pressed
  1542.   #     key : Key constant to test
  1543.   #-----------------------------------------------------------------------------
  1544.   def self.press?(key)
  1545.     return IsPressed.call(key) if key.is_a?(Fixnum)
  1546.     return key.any? {|k| IsPressed.call(k) != 0 }
  1547.   end
  1548.   #-----------------------------------------------------------------------------
  1549.   # * Key Repeated
  1550.   #     key : Key constant to test
  1551.   #-----------------------------------------------------------------------------
  1552.   def self.repeat?(key)
  1553.     return IsRepeated.call(key) if key.is_a?(Fixnum)
  1554.     return key.any? {|k| IsRepeated.call(k) != 0 }
  1555.   end
  1556.   #-----------------------------------------------------------------------------
  1557.   # * Key Released
  1558.   #     key : Key constant to test
  1559.   #-----------------------------------------------------------------------------
  1560.   def self.release?(key)
  1561.     return IsReleased.call(key) if key.is_a?(Fixnum)
  1562.     return key.any? {|k| IsReleased.call(k) != 0 }
  1563.   end
  1564.   #-----------------------------------------------------------------------------
  1565.   # * Mouse Double-Click
  1566.   #     key : Key constant to test
  1567.   #-----------------------------------------------------------------------------
  1568.   def self.dbl_click?(key)
  1569.     return IsDoubleClick.call(key) if key.is_a?(Fixnum)
  1570.     return key.any? {|k| IsDoubleClick.call(k) != 0 }
  1571.   end
  1572.   #-----------------------------------------------------------------------------
  1573.   # * Begin Key Logging
  1574.   #-----------------------------------------------------------------------------
  1575.   def self.begin_capture
  1576.     BeginCapture.call
  1577.   end
  1578.   #-----------------------------------------------------------------------------
  1579.   # * End Key Logging and Get String
  1580.   #-----------------------------------------------------------------------------
  1581.   def self.end_capture
  1582.     return EndCapture.call
  1583.   end
  1584.   #-----------------------------------------------------------------------------
  1585.   # * Current Mouse Position
  1586.   #-----------------------------------------------------------------------------
  1587.   def self.mouse_pos
  1588.     point = [0, 0].pack('ii')
  1589.     MousePosition.call(point)
  1590.     # Return mouse coordinates as two element array: [X, Y]
  1591.     return point.unpack('ii')
  1592.   end
  1593.   #-----------------------------------------------------------------------------
  1594.   # * Mouse is Moving
  1595.   #-----------------------------------------------------------------------------
  1596.   def self.mouse_moving?
  1597.     return IsMouseMoving.call != 0
  1598.   end
  1599.   #-----------------------------------------------------------------------------
  1600.   # * Mouse Wheel is Moving
  1601.   #-----------------------------------------------------------------------------
  1602.   def self.mouse_wheel?
  1603.     return IsWheelMoved.call != 0
  1604.   end
  1605.   #-----------------------------------------------------------------------------
  1606.   # * Mouse Wheel Amount
  1607.   #-----------------------------------------------------------------------------
  1608.   def self.wheel_delta
  1609.     return GetWheelDelta.call / 120
  1610.   end
  1611.   #-----------------------------------------------------------------------------
  1612.   # * Four Direction Check
  1613.   #-----------------------------------------------------------------------------
  1614.   def self.dir4
  1615.     return 2 if self.press?(DOWN)
  1616.     return 4 if self.press?(LEFT)
  1617.     return 6 if self.press?(RIGHT)
  1618.     return 8 if self.press?(UP)
  1619.     return 0
  1620.   end
  1621.   #-----------------------------------------------------------------------------
  1622.   # * Eight Direction Check
  1623.   #-----------------------------------------------------------------------------
  1624.   def self.dir8
  1625.     down = self.press?(DOWN)
  1626.     left = self.press?(LEFT)
  1627.     return 1 if down && left
  1628.     right = self.press?(RIGHT)
  1629.     return 3 if down && right
  1630.     up = self.press?(UP)
  1631.     return 7 if up && left
  1632.     return 9 if up && right
  1633.     return 2 if down
  1634.     return 4 if left
  1635.     return 6 if right
  1636.     return 8 if up
  1637.     return 0
  1638.   end
  1639. end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top