#============================================================================== # * Dax Core #============================================================================== # Autor : Dax Aquatic X # Coadjuvantes : # Gab!(Método de registrar scripts) # Gotoken : Módulo de Benchmark. # Module PNG&RTP : Autor desconhecido. # Versão : Core i8.61 # Site : www.dax-soft.weebly.com # Suporte : dax-soft@live.com #============================================================================== # Um Core com vários módulos e métodos que facilitará na hora de programar os # seus scripts, bom proveito. #============================================================================== # Conteúdo : • TAGS : Para facilitar a localização dos códigos e explicações. Para acessar # o comando para localizar, basta apertar Ctrl+F. #============================================================================== # i : # - Array :array # - Hash :hash # - API :api # - String :string # - Integer :integer # - Numeric :numeric # - Position :position # - File :file # - Dir :dir # - Rect :rect # - Color :color # - DMath :dmath # - Key :key # - Mouse :mouse # - Object :object # - Entries :entries # - DRGSS :drgss # - Backup :backup # - SceneManager :scenemanager # - Sprite_Text :sprite_text # - Opacity :opacity # - Read :read # - Window_Base :window_base # - SoundBase :soundbase # - Benchmark :benchmark # - Input :input # - Graphics :graphics # - Powershell :powershell #============================================================================== # • Adicionado comentário padrão. Veja o modo que agora os comentários dos # métodos estão. #============================================================================== # • [Classe do Retorno] : Explicação. # * Exemplo.(Se possível.) #============================================================================== module Dax extend self #---------------------------------------------------------------------------- # • Constantes : #---------------------------------------------------------------------------- # A imagem do ícone do Mouse tem que estar na pasta [System]. Basta você # por o nome da imagem dentro das áspas. Caso você queira usar um ícone # do Rpg Maker no lugar de uma imagem, basta você por o id do ícone no lugar # das áspas. MOUSE_NAME = "" #---------------------------------------------------------------------------- # • Variáveis. #---------------------------------------------------------------------------- @@data = {} # Variável que irá cuidar do registro. @@__data = {} # Variável cache do registro. #---------------------------------------------------------------------------- # • [NilClas] : Registrar o script, caso já exista ele atualiza. # [symbol] : name : Nome do script. # [string] : author : Autor(es) do script. # [numeric] : version : Versão do script. # [array] : requires : Requerimento para o script ser executado. OPCIONAL # [proc] : &block : Bloco do script que será executado. # # requires : Defina dentro da array, uma outra array, que contenha # o nome do script, o nome do autor e caso deseja, a versão do mesmo. # # * Script registrado. # # Dax.register(:test, "dax", 1.0) { # Test = Class.new { def initialize; msgbox("ok"); end; } # Test.new # } # # * Script registrado com requerimentos. # # Dax.register(:test2, "dax", 1.0, [[:test, "dax", 1.0]]) { # Test.new # } #---------------------------------------------------------------------------- def register(name, author, version, requires=[], &block) need = [] requires.each { |data| need << data unless self.registred?(*data) } if need.empty? @@data[[name, author]] = version block.call @@__data.each_pair { |(cache_name, cache_author, cache_version), (_need, _block)| _need.delete_if { |_n_| self.registred?(*_n_) } next unless _need.empty? @@__data.delete([cache_name, cache_author, cache_version]) self.register(cache_name, cache_author, cache_version, &_block) } else @@__data[[name, author, version]] = [need, block] end return nil end #---------------------------------------------------------------------------- # • [Boolean] : Verificar se está registrado. # [symbol] : name : Nome do script. # [string] : author : Autor(es) do script. # [numeric] : version : Versão do script. # [array] : requires : Requerimento para o script ser executado. OPCIONAL #---------------------------------------------------------------------------- def registred?(name, author, version=nil) if @@data.has_key?([name, author]) return true if version.nil? _version = @@data[[name, author]] return _version >= version else return false end end #---------------------------------------------------------------------------- # • Definir um script como requisição. Caso o script não exista, uma mensagem # de erro será executado. # [symbol] : name : Nome do script. # [string] : author : Autor(es) do script. # [numeric] : version : Versão do script. #---------------------------------------------------------------------------- def required(name, author, version=nil) if @@data.has_key?([name, author]) return true if version.nil? _version = @@data[[name, author]] if _version >= version return true else msgbox("Script desatualizado: #{String(name)} v#{String(_version)} por #{String(author)}\nVersão requerida: #{version}") exit end else msgbox("Script não encontrado: #{String(name)} v#{String(version)} por #{String(author)}") exit end end #---------------------------------------------------------------------------- # • Retorna a variável @@data. #---------------------------------------------------------------------------- def data @@data end #---------------------------------------------------------------------------- # * Remove uma [Classe], exemplo: Dax.remove(:Scene_Menu) #---------------------------------------------------------------------------- def remove(symbol_name) Object.send(:remove_const, symbol_name) end end #============================================================================== # • Array #============================================================================== Dax.register(:array, "dax", 2.0) { class Array attr_reader :next attr_reader :pred #---------------------------------------------------------------------------- # • [Hash] : Transforma a Array para uma Hash. # Define um valor padrão para todas as chaves. # [1, 2].to_hash_keys { :default_value } # { 1 => :default_value, 2 => :default_value } #---------------------------------------------------------------------------- def to_hash_keys(&block) Hash[*self.collect { |v| [v, block.call(v)] }.flatten] end #---------------------------------------------------------------------------- # • [Array] : Sorteia os objetos em ordem crescente. #---------------------------------------------------------------------------- def crescent sort! { |a, b| a <=> b } end #---------------------------------------------------------------------------- # • [Array] : Sorteia os objetos em ordem decrescente. #---------------------------------------------------------------------------- def decrescent sort! { |a, b| b <=> a } end #---------------------------------------------------------------------------- # • [Object] : Retorna para o próximo objeto da id da Array. # x = [1, 8] # x.next # 1 # x.next # 8 #---------------------------------------------------------------------------- def next(x=0) @next = (@next.nil? ? 0 : @next == self.size - 1 ? 0 : @next.next + x) return self[@next] end alias :+@ :next #---------------------------------------------------------------------------- # • [Object] : Retorna para o objeto anterior da id da Array. # x = [1, 8] # x.prev # 8 # x.prev # 1 #---------------------------------------------------------------------------- def pred(x = 0) @prev = (@prev.nil? ? self.size-1 : @prev == 0 ? self.size-1 : @prev.pred + x) return self[@prev] end alias :-@ :pred #---------------------------------------------------------------------------- # • [Array] Retorna ao elemento da array que condiz com a condição # definida no bloco. # Exemplo: # [2, 4, 5, 6, 8].if { |element| element >= 4 } # # 5, 6, 8 #---------------------------------------------------------------------------- def if return unless block_given? getResult = [] self.each_with_index{ |arrays| getResult << arrays if yield(arrays) } return getResult end #---------------------------------------------------------------------------- # • [Mixed] : Retorna ao primeiro valor da array, que obedeça a # condição posta. # msgbox [2, 3, 4, 5, 6].first! { |n| n.is_evan? } #> 2 # msgbox [2, 3, 4, 5, 6].first! { |n| n.is_odd? } #> 3 #---------------------------------------------------------------------------- def first! return unless block_given? return self.each { |element| return element if yield(element) }.at(0) end #---------------------------------------------------------------------------- # • [Numeric] : Retorna ao valor de todos os conteúdos, desde que seja números, # somados, ou subtraidos, ou multiplicado. Por padrão é soma. # v : :+ # Somar # :- # Subtrair # :* # Multiplicar. #---------------------------------------------------------------------------- def alln?(v=:+) n = v == :* ? 1 : 0 self.if {|i| i.is_a?(Numeric) }.each { |content| n += content if v == :+ n -= content if v == :- n *= content if v == :* } return n end end } #============================================================================== # • Hash #============================================================================== Dax.register(:hash, "dax", 1.3) { class Hash #---------------------------------------------------------------------------- # • [NilClass or Mixed] : Pega o valor da chave específicada. # key : Chave. # block(proc) : Condição para que retorna ao valor da chave. Opcional. # {1 => 12}.get(1) #=> 12 # {1 => 12}.get(1) { |k| k.is_a?(String) } #=> nil #---------------------------------------------------------------------------- def get(key) if block_given? self.keys.each { |data| next unless key == data return self[data] if yield(self[data]) } else self.keys.each { |data| return self[data] if key == data } end return nil end #---------------------------------------------------------------------------- # • [Mix] : Retorna a última chave adicionada. #---------------------------------------------------------------------------- def last_key return self.keys.last end end } #============================================================================== # • API : Módulo que armazena informações de algumas APIS. #============================================================================== Dax.register(:api, "dax", 3.0) { module API extend self #---------------------------------------------------------------------------- # • [String] : Tipos e seus retornos.. Pegado da internet.. Autor desconhecido #---------------------------------------------------------------------------- TYPES = { struct: "p", int: "i", long: "l", INTERNET_PORT: "l", SOCKET: "p", C: "p", #– 8-bit unsigned character (byte) c: "p", # 8-bit character (byte) # "i"8 – 8-bit signed integer # "i"8 – 8-bit unsigned integer S: "N", # – 16-bit unsigned integer (Win32/API: S used for string params) s: "n", # – 16-bit signed integer # "i"16 – 16-bit unsigned integer # "i"16 – 16-bit signed integer I: "I", # 32-bit unsigned integer i: "i", # 32-bit signed integer # "i"32 – 32-bit unsigned integer # "i"32 – 32-bit signed integer L: "L", # unsigned long int – platform-specific size l: "l", # long int – platform-specific size. For discussion of platforms, see: # (http://groups.google.com/group/ruby-ffi/browse_thread/thread/4762fc77130339b1) # "i"64 – 64-bit signed integer # "i"64 – 64-bit unsigned integer # "l"_long – 64-bit signed integer # "l"_long – 64-bit unsigned integer F: "L", # 32-bit floating point D: "L", # 64-bit floating point (double-precision) P: "P", # pointer – platform-specific size p: "p", # C-style (NULL-terminated) character string (Win32API: S) B: "i", # (?? 1 byte in C++) V: "V", # For functions that return nothing (return type void). v: "v", # For functions that return nothing (return type void). LPPOINT: "p", # Windows-specific type defs (ms-help://MS.MSDNQTR.v90.en/winprog/winprog/windows_data_types.htm): ATOM: "I", # Atom ~= Symbol: Atom table stores strings and corresponding identifiers. Application # places a string in an atom table and receives a 16-bit integer, called an atom, that # can be used to access the string. Placed string is called an atom name. # See: http://msdn.microsoft.com/en-us/library/ms648708%28VS.85%29.aspx BOOL: "i", BOOLEAN: "i", BYTE: "p", # Byte (8 bits). Declared as unsigned char #CALLBACK: K, # Win32.API gem-specific ?? MSDN: #define CALLBACK __stdcall CHAR: "p", # 8-bit Windows (ANSI) character. See http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx COLORREF: "i", # Red, green, blue (RGB) color value (32 bits). See COLORREF for more info. DWORD: "i", # 32-bit unsigned integer. The range is 0 through 4,294,967,295 decimal. DWORDLONG: "i", # 64-bit unsigned integer. The range is 0 through 18,446,744,073,709,551,615 decimal. DWORD_PTR: "l", # Unsigned long type for pointer precision. Use when casting a pointer to a long type # to perform pointer arithmetic. (Also commonly used for general 32-bit parameters that have # been extended to 64 bits in 64-bit Windows.) BaseTsd.h: #typedef ULONG_PTR DWORD_PTR; DWORD32: "I", DWORD64: "I", HALF_PTR: "i", # Half the size of a pointer. Use within a structure that contains a pointer and two small fields. # BaseTsd.h: #ifdef (_WIN64) typedef int HALF_PTR; #else typedef short HALF_PTR; HACCEL: "i", # (L) Handle to an accelerator table. WinDef.h: #typedef HANDLE HACCEL; # See http://msdn.microsoft.com/en-us/library/ms645526%28VS.85%29.aspx HANDLE: "l", # (L) Handle to an object. WinNT.h: #typedef PVOID HANDLE; # todo: Platform-dependent! Need to change to "i"64 for Win64 HBITMAP: "l", # (L) Handle to a bitmap: http://msdn.microsoft.com/en-us/library/dd183377%28VS.85%29.aspx HBRUSH: "l", # (L) Handle to a brush. http://msdn.microsoft.com/en-us/library/dd183394%28VS.85%29.aspx HCOLORSPACE: "l", # (L) Handle to a color space. http://msdn.microsoft.com/en-us/library/ms536546%28VS.85%29.aspx HCURSOR: "l", # (L) Handle to a cursor. http://msdn.microsoft.com/en-us/library/ms646970%28VS.85%29.aspx HCONV: "l", # (L) Handle to a dynamic data exchange (DDE) conversation. HCONVLIST: "l", # (L) Handle to a DDE conversation list. HANDLE - L ? HDDEDATA: "l", # (L) Handle to DDE data (structure?) HDC: "l", # (L) Handle to a device context (DC). http://msdn.microsoft.com/en-us/library/dd183560%28VS.85%29.aspx HDESK: "l", # (L) Handle to a desktop. http://msdn.microsoft.com/en-us/library/ms682573%28VS.85%29.aspx HDROP: "l", # (L) Handle to an internal drop structure. HDWP: "l", # (L) Handle to a deferred window position structure. HENHMETAFILE: "l", #(L) Handle to an enhanced metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx HFILE: "i", # (I) Special file handle to a file opened by OpenFile, not CreateFile. # WinDef.h: #typedef int HFILE; REGSAM: "i", HFONT: "l", # (L) Handle to a font. http://msdn.microsoft.com/en-us/library/dd162470%28VS.85%29.aspx HGDIOBJ: "l", # (L) Handle to a GDI object. HGLOBAL: "l", # (L) Handle to a global memory block. HHOOK: "l", # (L) Handle to a hook. http://msdn.microsoft.com/en-us/library/ms632589%28VS.85%29.aspx HICON: "l", # (L) Handle to an icon. http://msdn.microsoft.com/en-us/library/ms646973%28VS.85%29.aspx HINSTANCE: "l", # (L) Handle to an instance. This is the base address of the module in memory. # HMODULE and HINSTANCE are the same today, but were different in 16-bit Windows. HKEY: "l", # (L) Handle to a registry key. HKL: "l", # (L) Input locale identifier. HLOCAL: "l", # (L) Handle to a local memory block. HMENU: "l", # (L) Handle to a menu. http://msdn.microsoft.com/en-us/library/ms646977%28VS.85%29.aspx HMETAFILE: "l", # (L) Handle to a metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx HMODULE: "l", # (L) Handle to an instance. Same as HINSTANCE today, but was different in 16-bit Windows. HMONITOR: "l", # (L) ?andle to a display monitor. WinDef.h: if(WINVER >= 0x0500) typedef HANDLE HMONITOR; HPALETTE: "l", # (L) Handle to a palette. HPEN: "l", # (L) Handle to a pen. http://msdn.microsoft.com/en-us/library/dd162786%28VS.85%29.aspx HRESULT: "l", # Return code used by COM interfaces. For more info, Structure of the COM Error Codes. # To test an HRESULT value, use the FAILED and SUCCEEDED macros. HRGN: "l", # (L) Handle to a region. http://msdn.microsoft.com/en-us/library/dd162913%28VS.85%29.aspx HRSRC: "l", # (L) Handle to a resource. HSZ: "l", # (L) Handle to a DDE string. HWINSTA: "l", # (L) Handle to a window station. http://msdn.microsoft.com/en-us/library/ms687096%28VS.85%29.aspx HWND: "l", # (L) Handle to a window. http://msdn.microsoft.com/en-us/library/ms632595%28VS.85%29.aspx INT: "i", # 32-bit signed integer. The range is -2147483648 through 2147483647 decimal. INT_PTR: "i", # Signed integer type for pointer precision. Use when casting a pointer to an integer # to perform pointer arithmetic. BaseTsd.h: #if defined(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR; INT32: "i", # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal. INT64: "i", # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807 LANGID: "n", # Language identifier. For more information, see Locales. WinNT.h: #typedef WORD LANGID; # See http://msdn.microsoft.com/en-us/library/dd318716%28VS.85%29.aspx LCID: "i", # Locale identifier. For more information, see Locales. LCTYPE: "i", # Locale information type. For a list, see Locale Information Constants. LGRPID: "i", # Language group identifier. For a list, see EnumLanguageGroupLocales. LONG: "l", # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal. LONG32: "i", # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal. LONG64: "i", # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807 LONGLONG: "i", # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807 LONG_PTR: "l", # Signed long type for pointer precision. Use when casting a pointer to a long to # perform pointer arithmetic. BaseTsd.h: #if defined(_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR; LPARAM: "l", # Message parameter. WinDef.h as follows: #typedef LONG_PTR LPARAM; LPBOOL: "i", # Pointer to a BOOL. WinDef.h as follows: #typedef BOOL far *LPBOOL; LPBYTE: "i", # Pointer to a BYTE. WinDef.h as follows: #typedef BYTE far *LPBYTE; LPCSTR: "p", # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters. # See Character Sets Used By Fonts. http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx LPCTSTR: "p", # An LPCWSTR if UNICODE is defined, an LPCSTR otherwise. LPCVOID: "v", # Pointer to a constant of any type. WinDef.h as follows: typedef CONST void *LPCVOID; LPCWSTR: "P", # Pointer to a constant null-terminated string of 16-bit Unicode characters. LPDWORD: "p", # Pointer to a DWORD. WinDef.h as follows: typedef DWORD *LPDWORD; LPHANDLE: "l", # Pointer to a HANDLE. WinDef.h as follows: typedef HANDLE *LPHANDLE; LPINT: "I", # Pointer to an INT. LPLONG: "L", # Pointer to an LONG. LPSTR: "p", # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters. LPTSTR: "p", # An LPWSTR if UNICODE is defined, an LPSTR otherwise. LPVOID: "v", # Pointer to any type. LPWORD: "p", # Pointer to a WORD. LPWSTR: "p", # Pointer to a null-terminated string of 16-bit Unicode characters. LRESULT: "l", # Signed result of message processing. WinDef.h: typedef LONG_PTR LRESULT; PBOOL: "i", # Pointer to a BOOL. PBOOLEAN: "i", # Pointer to a BOOL. PBYTE: "i", # Pointer to a BYTE. PCHAR: "p", # Pointer to a CHAR. PCSTR: "p", # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters. PCTSTR: "p", # A PCWSTR if UNICODE is defined, a PCSTR otherwise. PCWSTR: "p", # Pointer to a constant null-terminated string of 16-bit Unicode characters. PDWORD: "p", # Pointer to a DWORD. PDWORDLONG: "L", # Pointer to a DWORDLONG. PDWORD_PTR: "L", # Pointer to a DWORD_PTR. PDWORD32: "L", # Pointer to a DWORD32. PDWORD64: "L", # Pointer to a DWORD64. PFLOAT: "L", # Pointer to a FLOAT. PHALF_PTR: "L", # Pointer to a HALF_PTR. PHANDLE: "L", # Pointer to a HANDLE. PHKEY: "L", # Pointer to an HKEY. PINT: "i", # Pointer to an INT. PINT_PTR: "i", # Pointer to an INT_PTR. PINT32: "i", # Pointer to an INT32. PINT64: "i", # Pointer to an INT64. PLCID: "l", # Pointer to an LCID. PLONG: "l", # Pointer to a LONG. PLONGLONG: "l", # Pointer to a LONGLONG. PLONG_PTR: "l", # Pointer to a LONG_PTR. PLONG32: "l", # Pointer to a LONG32. PLONG64: "l", # Pointer to a LONG64. POINTER_32: "l", # 32-bit pointer. On a 32-bit system, this is a native pointer. On a 64-bit system, this is a truncated 64-bit pointer. POINTER_64: "l", # 64-bit pointer. On a 64-bit system, this is a native pointer. On a 32-bit system, this is a sign-extended 32-bit pointer. POINTER_SIGNED: "l", # A signed pointer. HPSS: "l", POINTER_UNSIGNED: "l", # An unsigned pointer. PSHORT: "l", # Pointer to a SHORT. PSIZE_T: "l", # Pointer to a SIZE_T. PSSIZE_T: "l", # Pointer to a SSIZE_T. PSS_CAPTURE_FLAGS: "l", PSTR: "p", # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts. PTBYTE: "p", # Pointer to a TBYTE. PTCHAR: "p", # Pointer to a TCHAR. PTSTR: "p", # A PWSTR if UNICODE is defined, a PSTR otherwise. PUCHAR: "p", # Pointer to a UCHAR. PUINT: "i", # Pointer to a UINT. PUINT_PTR: "i", # Pointer to a UINT_PTR. PUINT32: "i", # Pointer to a UINT32. PUINT64: "i", # Pointer to a UINT64. PULONG: "l", # Pointer to a ULONG. PULONGLONG: "l", # Pointer to a ULONGLONG. PULONG_PTR: "l", # Pointer to a ULONG_PTR. PULONG32: "l", # Pointer to a ULONG32. PULONG64: "l", # Pointer to a ULONG64. PUSHORT: "l", # Pointer to a USHORT. PVOID: "v", # Pointer to any type. PWCHAR: "p", # Pointer to a WCHAR. PWORD: "p", # Pointer to a WORD. PWSTR: "p", # Pointer to a null- terminated string of 16-bit Unicode characters. # For more information, see Character Sets Used By Fonts. SC_HANDLE: "l", # (L) Handle to a service control manager database. SERVICE_STATUS_HANDLE: "l", # (L) Handle to a service status value. See SCM Handles. SHORT: "i", # A 16-bit integer. The range is –32768 through 32767 decimal. SIZE_T: "l", # The maximum number of bytes to which a pointer can point. Use for a count that must span the full range of a pointer. SSIZE_T: "l", # Signed SIZE_T. TBYTE: "p", # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR: # http://msdn.microsoft.com/en-us/library/c426s321%28VS.80%29.aspx TCHAR: "p", # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR: UCHAR: "p", # Unsigned CHAR (8 bit) UHALF_PTR: "i", # Unsigned HALF_PTR. Use within a structure that contains a pointer and two small fields. UINT: "i", # Unsigned INT. The range is 0 through 4294967295 decimal. UINT_PTR: "i", # Unsigned INT_PTR. UINT32: "i", # Unsigned INT32. The range is 0 through 4294967295 decimal. UINT64: "i", # Unsigned INT64. The range is 0 through 18446744073709551615 decimal. ULONG: "l", # Unsigned LONG. The range is 0 through 4294967295 decimal. ULONGLONG: "l", # 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal. ULONG_PTR: "l", # Unsigned LONG_PTR. ULONG32: "i", # Unsigned INT32. The range is 0 through 4294967295 decimal. ULONG64: "i", # Unsigned LONG64. The range is 0 through 18446744073709551615 decimal. UNICODE_STRING: "P", # Pointer to some string structure?? USHORT: "i", # Unsigned SHORT. The range is 0 through 65535 decimal. USN: "l", # Update sequence number (USN). WCHAR: "i", # 16-bit Unicode character. For more information, see Character Sets Used By Fonts. # In WinNT.h: typedef wchar_t WCHAR; #WINAPI: K, # Calling convention for system functions. WinDef.h: define WINAPI __stdcall WORD: "i", # 16-bit unsigned integer. The range is 0 through 65535 decimal. WPARAM: "i", # Message parameter. WinDef.h as follows: typedef UINT_PTR WPARAM; VOID: "v", # Any type ? Only use it to indicate no arguments or no return value vKey: "i", LPRECT: "p", char: "p", } #---------------------------------------------------------------------------- # • [Array] : Pega os valores especificados no método.. depois verifica # cada um se é String ou Symbol. Se for Symbol retorna ao valor especificado # na Constante TYPES. # Exemplo: types([:BOOL, :WCHAR]) # ["i", "i"] #---------------------------------------------------------------------------- def types(import) import2 = [] import.each { |i| next if i.is_a?(NilClass) or i.is_a?(String) import2 << TYPES[i] } return import2 end #---------------------------------------------------------------------------- # • [Dll]// : Especifica uma função, com o valor da importação é a DLL.. # Por padrão a DLL é a "user32". O valor de exportação será "i" #---------------------------------------------------------------------------- def int(function, import, dll="user32") api = Win32API.new(dll, function, types(import), "i") rescue nil return api unless block_given? return Module.new { yield.each { |key, value| define_method(key) { return value.is_a?(Array) ? api.call(*value) : value } module_function key } if yield.is_a?(Hash) define_method(:call) { |*args| api.call(*args) } module_function(:call) } end alias :bool :int #---------------------------------------------------------------------------- # • [Dll]// : Especifica uma função, com o valor da importação é a DLL.. # Por padrão a DLL é a "user32". O valor de exportação será "l" #---------------------------------------------------------------------------- def long(function, import, dll="user32") api = Win32API.new(dll, function, types(import), "l") rescue nil return api unless block_given? return Module.new { yield.each { |key, value| define_method(key) { return value.is_a?(Array) ? api.call(*value) : value } module_function key } if yield.is_a?(Hash) define_method(:call) { |*args| api.call(*args) } module_function(:call) } end #---------------------------------------------------------------------------- # • [Dll]// : Especifica uma função, com o valor da importação é a DLL.. # Por padrão a DLL é a "user32". O valor de exportação será "v" #---------------------------------------------------------------------------- def void(function, import, dll="user32") api = Win32API.new(dll, function, types(import), "v") rescue nil return api unless block_given? return Module.new { yield.each { |key, value| define_method(key) { return value.is_a?(Array) ? api.call(*value) : value } module_function key } if yield.is_a?(Hash) define_method(:call) { |*args| api.call(*args) } module_function(:call) } end #---------------------------------------------------------------------------- # • [Dll]// : Especifica uma função, com o valor da importação é a DLL.. # Por padrão a DLL é a "user32". O valor de exportação será "p" #---------------------------------------------------------------------------- def char(function, import, dll="user32") api = Win32API.new(dll, function, types(import), "p") rescue nil return api unless block_given? return Module.new { yield.each { |key, value| define_method(key) { return value.is_a?(Array) ? api.call(*value) : value } module_function key } if yield.is_a?(Hash) define_method(:call) { |*args| api.call(*args) } module_function(:call) } end #---------------------------------------------------------------------------- # • [Dll]// : Com esse método você pode especificar uma função de uma Dll. # function(export, function, import, dll) # export : Valor da exportação. Formato [Symbol] # function : Função da Dll. # import : Valor da importação. # dll : Dll. Por padrão é a User32 # Esconder o Mouse. # Exemplo: function(:int, "ShowCursor", [:BOOL]).call(0) #---------------------------------------------------------------------------- def function(export, function, import, dll="user32") eval("#{export}(function, import, dll)") end #---------------------------------------------------------------------------- # • Especificando o método protegido. #---------------------------------------------------------------------------- # Métodos privados. private :long, :int, :char, :void, :types #---------------------------------------------------------------------------- # • [CopyFile]/Dll : Função da DLL Kernel32 que permite copiar arquivos. # CopyFile.call(filename_to_copy, filename_copied, replace) # filename_to_copy : Formato [String] # filename_copied : Formato [String] # replace : Formato [Integer] 0 - false 1 - true # Exemplo: CopyFile.call("System/RGSS300.dll", "./RGSS300.dll", 1) #---------------------------------------------------------------------------- CopyFile = long("CopyFile", [:LPCTSTR, :LPCTSTR, :BOOL], "kernel32") #---------------------------------------------------------------------------- # • [Beep]/Dll : Emitir uma frequência de um som do sistema com duração. # Beep.call(freq, duration) # freq : Formato [Integer\Hexadécimal] # duration : Formato [Integer\Hexadécimal] # Exemplo: Beep.call(2145, 51) #---------------------------------------------------------------------------- Beep = long('Beep', [:DWORD, :DWORD], 'kernel32') #---------------------------------------------------------------------------- # • [keybd_event]/Dll : Ela é usada para sintentizar uma combinação de teclas. # KEYBD_EVENT.call(vk, scan, fdwFlags, dwExtraInfo) # vk : Formato [Integer/Hexadécimal]. # scan : Formato [Integer] # fdwFlags : Formato [Integer] # dwExtraInfo : Formato [Integer] # Exemplo: KEYBD_EVENT.call(0x01, 0, 0, 0) #---------------------------------------------------------------------------- KEYBD_EVENT = void('keybd_event', [:BYTE, :BYTE, :DWORD, :ULONG_PTR]) #---------------------------------------------------------------------------- # • Função de limpar memória. # Permite definir por um comando eval algo que aconteça antes. # Permite definir com um bloco, algo que aconteça no processo. #---------------------------------------------------------------------------- def clearMemory(deval="", &block) eval(deval) unless deval.empty? and !deval.is_a?(String) KEYBD_EVENT.call(0x7B, 0, 0, 0) block.call if block_given? sleep(0.1) KEYBD_EVENT.call(0x7B, 0, 2, 0) end #---------------------------------------------------------------------------- # • Tela chéia #---------------------------------------------------------------------------- def full_screen KEYBD_EVENT.(18, 0, 0, 0) KEYBD_EVENT.(18, 0, 0, 0) KEYBD_EVENT.(13, 0, 0, 0) KEYBD_EVENT.(13, 0, 2, 0) KEYBD_EVENT.(18, 0, 2, 0) end #---------------------------------------------------------------------------- # • [GetKeyState]/Dll : Pega o status da chave. # GetKeyState.call(vk) # vk : Formato [Integer/Hexadécimal]. # Exemplo: GetKeyState.call(0x01) #---------------------------------------------------------------------------- GetKeyState = int('GetAsyncKeyState', [:int]) #---------------------------------------------------------------------------- # • [MapVirtualKey] : Traduz (maps) o código de uma key para um código # escaneado ou o valor de um character. #---------------------------------------------------------------------------- MapVirtualKey = int("MapVirtualKey", [:UINT, :UINT]) #---------------------------------------------------------------------------- # • [MouseShowCursor]/Dll : Mostrar ou desativar o cusor do Mouse. # MouseShowCursor.call(value) # value : Formato [Integer] 0 - false 1 - true # Exemplo: MouseShowCursor.call(0) #---------------------------------------------------------------------------- MouseShowCursor = int("ShowCursor", [:int]) #---------------------------------------------------------------------------- # • [CursorPosition]/Dll : Obtem a posição do cursor do Mouse na tela. # CursorPosition.call(lpPoint) # lpPoint : Formato [Array] # Ex: CursorPosition.call([0, 0].pack('ll')) #---------------------------------------------------------------------------- CursorPosition = int('GetCursorPos', [:LPPOINT]) #---------------------------------------------------------------------------- # • [ScreenToClient]/Dll : Converte as coordenadas da tela para um ponto # em especifico da área da tela do cliente. # ScreenToClient.call(hWnd, lpPoint) #---------------------------------------------------------------------------- ScreenToClient = int('ScreenToClient', [:HWND, :LPPOINT]) #---------------------------------------------------------------------------- # • [GetPrivateProfileString]/Dll : */Ainda não explicado./* #---------------------------------------------------------------------------- GetPrivateProfileString = long('GetPrivateProfileStringA', [:LPCTSTR, :LPCTSTR, :LPCTSTR, :LPTSTR, :DWORD, :LPCTSTR], 'kernel32') #---------------------------------------------------------------------------- # • [FindWindow]/Dll : Recupera o identificador da janela superior. Cujo # o nome da janela é o nome da classe da janela se combina com as cadeias # especificas. # FindWindow.call(lpClassName, lpWindowName) # lpClassName : Formato [String] # lpWindowName : Formato [String] #---------------------------------------------------------------------------- FindWindow = long('FindWindowA', [:LPCTSTR, :LPCTSTR]) #---------------------------------------------------------------------------- # • [Handle]/Dll : Retorna ao Handle da janela. #---------------------------------------------------------------------------- def hWND(game_title=nil) return API::FindWindow.call('RGSS Player', game_title || load_data("Data/System.rvdata2").game_title.to_s) rescue nil end #---------------------------------------------------------------------------- # • [Handle]/Dll : Retorna ao Handle da janela. Método protegido. #---------------------------------------------------------------------------- def hwnd(*args) hWND(*args) end #---------------------------------------------------------------------------- # • [ReadIni]/Dll : */Ainda não explicado./* #---------------------------------------------------------------------------- ReadIni = GetPrivateProfileString #---------------------------------------------------------------------------- # • [SetWindowPos]/Dll : Modifica os elementos da janela como, posição, tamanho. #---------------------------------------------------------------------------- SetWindowPos = int("SetWindowPos", [:HWND, :HWND, :int, :int, :int, :int, :UINT]) #---------------------------------------------------------------------------- # • [GetWindowRect]/Dll : Obtem as dimensões do retângulo da janela. # GetWindowRect.call(hWnd, lpRect) #---------------------------------------------------------------------------- GetWindowRect = int('GetWindowRect', [:HWND, :LPRECT]) #---------------------------------------------------------------------------- # • [StateKey]/Dll : Retorna ao status específico da chave. # StateKey.call(VK) # VK : Formato [Integer/Hexadécimal]. #---------------------------------------------------------------------------- StateKey = int("GetKeyState", [:int]) #---------------------------------------------------------------------------- # • [SetCursorPos]/Dll : Move o cursor do Mouse para um ponto específico # da tela. # SetCursorPos.call(x, y) # x, y : Formato [Integer/Float] #---------------------------------------------------------------------------- SetCursorPos = int("SetCursorPos", [:long, :long]) #---------------------------------------------------------------------------- # • [GetKeyboardState]/Dll : Cópia o status das 256 chaves para um # buffer especificado. #---------------------------------------------------------------------------- GetKeyboardState = Win32API.new('user32', 'GetKeyboardState', ['P'], 'V') #---------------------------------------------------------------------------- # • [GetAsyncKeyState]/Dll : Determina o estado da chave no momento em que a # função é chamada. # GetAsyncKeyState.call(Vk) # VK : Formato [Integer/Hexadécimal]. #---------------------------------------------------------------------------- GetAsyncKeyState = int('GetAsyncKeyState', [:int]) #---------------------------------------------------------------------------- # • [WideCharToMultiByte] : [MultiByteToWideChar] // Comentários # não adicionados. #---------------------------------------------------------------------------- WideCharToMultiByte = Win32API.new('kernel32', 'WideCharToMultiByte', 'ilpipipp', 'i') MultiByteToWideChar = Win32API.new('kernel32', 'MultiByteToWideChar', 'ilpipi', 'i') #---------------------------------------------------------------------------- # • [AdjustWindowRect] : Calcula o tamanho requerido do retângulo da Janela. #---------------------------------------------------------------------------- AdjustWindowRect = int("AdjustWindowRect", [:LPRECT, :DWORD, :BOOL]) #---------------------------------------------------------------------------- # • Constantes [SetWindowPos] #---------------------------------------------------------------------------- SWP_ASYNCWINDOWPOS = 0x4000 # Desenha os frames (definidos na classe da janela descrita) em torno na janela. SWP_DRAWFRAME = 0x0020 # Esconde a janela. SWP_HIDEWINDOW = 0x0080 # Não pode ser ativada nem movida SWP_NOACTIVATE = 0x0010 # Não permite mover SWP_NOMOVE = 0x0002 # Não permite redimensionar SWP_NOSIZE = 0x0001 # Mostra a Janela SWP_SHOWWINDOW = 0x0040 # Coloca a janela na parte inferior na ordem de Z. Se identificar uma janela # superior ela perde os seus status. HWND_BOTTOM = 1 # Coloca a janela acima de todas as janelas que não estão em primeiro plano. HWND_NOTOPMOST = -2 # Poem a janela no Topo na ordem de Z. HWND_TOP = 0 # Poem a janela acima de todas que não estão em primeiro plano. Mantendo a # posição. HWND_TOPMOST = -1 #---------------------------------------------------------------------------- # • [SetActiveWindow]/ Dll : Ativa a Window. #---------------------------------------------------------------------------- SetActiveWindow = long("SetActiveWindow", [:HWND]) #---------------------------------------------------------------------------- # • WindowFromPoint : Retorna ao handle da janela, que contém um ponto # específico. #---------------------------------------------------------------------------- WindowFromPoint = long("WindowFromPoint", [:HWND]) #---------------------------------------------------------------------------- # • ShowWindow : Mostra a janela em um estado específico. #---------------------------------------------------------------------------- ShowWindow = long("ShowWindow", [:HWND, :LONG]) # Força a janela a minimizar SW_FORCEMINIMIZE = 11 # Esconde a janela, ativa outra. SW_HIDE = 0 # Maximiza a janela. SW_MAXIMIZE = 3 # Minimiza a janela SW_MINIMIZE = 6 # Restaura o estado da janela. SW_RESTORE = 9 # Ativa a janela a mostrando na posição original. SW_SHOW = 5 #---------------------------------------------------------------------------- # • [SetWindowText] : Permite modificar o título da janela. #---------------------------------------------------------------------------- SetWindowText = int("SetWindowText", [:HWND, :LPCTSTR]) #---------------------------------------------------------------------------- # • [GetDesktopWindow] : Retorna ao handle da janela em relação ao Desktop. #---------------------------------------------------------------------------- GetDesktopWindow = long("GetDesktopWindow", [:HWND]) #---------------------------------------------------------------------------- # • [GetSystemMetric] : Obtem um sistema métrico específico ou a configuração # do sistema. As dimensões retornadas são em pixel. #---------------------------------------------------------------------------- GetSystemMetric = int("GetSystemMetric", [:int]) #---------------------------------------------------------------------------- # • [GetSystemMetric]/Constantes: #---------------------------------------------------------------------------- # Obtem a flag que especifica como o sistema está organizando as janelas # minimizadas. SM_ARRANGE = 56 # Obtem o tamanho da borda da Janela em pixel. SM_CXBORDER = 5 # Valor do tamanho da área do cliente pra uma Janela em modo de tela-chéia. # em pixel. SM_CXFULLSCREEN = 16 # Para mais informações dos valores, visite : # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724385(v=vs.85).aspx #---------------------------------------------------------------------------- # • [GetClientRect] : Retorna ao rect da área da Janela. # Uses : # lpRect = [0,0,0,0].pack("L*") # GetClientRect.(hwnd, lpRect) # lpRect = lpRect.unpack("L*") #---------------------------------------------------------------------------- GetClientRect = int("GetClientRect", [:HWND, :LPRECT]) #---------------------------------------------------------------------------- # • [GetModuleHandle] : Retorna ao Handle do módulo, do módulo específicado. # Pode ser aquivo '.dll' ou '.exe'. Exemplo: # GetModuleHandle.call('System/RGSS300.dll') #---------------------------------------------------------------------------- GetModuleHandle = long("GetModuleHandle", [:LPCTSTR], "kerne32") #---------------------------------------------------------------------------- # • [FreeLibrary] : Libera o módulo que está carregado na DLL específica. #---------------------------------------------------------------------------- FreeLibrary = long("FreeLibrary", [:HMODULE], "kernel32") #---------------------------------------------------------------------------- # • [LoadLibrary] : Carrega um endereço de um módulo em específico. # LoadLibrary.call(Nome da Libraria(dll/exe)) # [Handle] : Retorna ao valor do Handle do módulo caso der certo. #---------------------------------------------------------------------------- LoadLibrary = long("LoadLibrary", [:LPCTSTR], "kernel32") #---------------------------------------------------------------------------- # • [GetProcAddress] : Retorna ao endereço da função exportada ou a variável # de uma DLL específica. # GetProcAddress.call(hModule, lpProcName) # hModule : É o valor do handle. Você pode pega-lo usando o LoadLibrary # lpProcName : A função ou o nome da variável. #---------------------------------------------------------------------------- GetProcAddress = long("GetProcAddress", [:HMODULE, :LPCSTR], "kernel32") #---------------------------------------------------------------------------- # • [GetSystemMetrics] : Retorna á uma configuração específica do sistema # métrico. #---------------------------------------------------------------------------- GetSystemMetrics = int("GetSystemMetrics", [:int]) #---------------------------------------------------------------------------- # • [GetSystemMetrics]::Constantes. #Para mais visite: # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724385(v=vs.85).aspx #---------------------------------------------------------------------------- SM_CXSCREEN = 0 # O tamanho(width/largura) da janela em pixel. SM_CYSCREEN = 1 # O tamanho(height/comprimento) da janela em pixel. SM_CXFULLSCREEN = 16 # O tamanho da largura da tela chéia da janela. SM_CYFULLSCREEN = 17 # O tamanho do comprimento da tela chéia da janela. #---------------------------------------------------------------------------- # • [SetPriorityClass] : Definir a classe prioritária para um processo # específico. # Para ver os processo e tal : Link abaixo. # http://msdn.microsoft.com/en-us/library/windows/desktop/ms686219(v=vs.85).aspx #---------------------------------------------------------------------------- SetPriorityClass = int("SetPriorityClass", [:HANDLE, :DWORD], "kernel32") #---------------------------------------------------------------------------- # • [InternetOpenA] : Inicializa o uso de uma aplicação, de uma função da # WinINet. #---------------------------------------------------------------------------- InternetOpenA = function(:int, "InternetOpenA", [:LPCTSTR, :DWORD, :LPCTSTR, :LPCTSTR, :DWORD], "wininet") #---------------------------------------------------------------------------- # • [RtlMoveMemory] : Movimenta um bloco de memoria para outra locação. #---------------------------------------------------------------------------- RtlMoveMemory = function(:int, "RtlMoveMemory", [:char, :char, :int], "kernel32") #---------------------------------------------------------------------------- # • [ShellExecute] : #---------------------------------------------------------------------------- ShellExecute = long("ShellExecute", [:LPCTSTR, :LPCTSTR, :LPCTSTR, :LPCTSTR, :LPCTSTR, :LONG], "Shell32.dll") #---------------------------------------------------------------------------- # • [Método protegido] : Método usado para chamar a função LoadLibrary. #---------------------------------------------------------------------------- def dlopen(name, fA=nil) l = LoadLibrary.(String(name)) return l if fA.nil? return GetProcAddress.(l, String(fA)) end #---------------------------------------------------------------------------- # • Converte um texto para o formato UTF-8 # textUTF(text) # * text : Texto. #---------------------------------------------------------------------------- def textUTF(text) wC = MultiByteToWideChar.call(65001, 0, text, -1, "", 0) MultiByteToWideChar.call(65001, 0, text, -1, text = "\0\0" * wC, wC) return text end #---------------------------------------------------------------------------- # • [TrueClass/FalseClass] : Retorna verdadeiro caso o Caps Lock esteja # ativo e retorna Falso caso não esteja ativo. #---------------------------------------------------------------------------- def get_caps_lock return int("GetKeyState", [:vKey]).call(20) == 1 end #---------------------------------------------------------------------------- # • Abre a URL de um site o direcionado para o navegador padrão do usuário. #---------------------------------------------------------------------------- def open_site(url) c = Win32API.new("Shell32", "ShellExecute", "pppppl", "l") c.call(nil, "open", url, nil, nil, 0) end #---------------------------------------------------------------------------- # • Valor dá base é o endereço. Pegar a variável. # base = 0x10000000 # adr_loc_ram(0x25EB00 + 0x214, val, base) #---------------------------------------------------------------------------- def adr_loc_ram(adr, val, base) return DL::CPtr.new(base + adr)[0, val.size] = size end #============================================================================ # • MessageBox #============================================================================ module MessageBox extend self # handle, string, title, format. FunctionMessageBox = Win32API.new("user32", "MessageBoxW", "lppl", "l") #-------------------------------------------------------------------------- # • [Constantes] Botões: #-------------------------------------------------------------------------- # Adiciona três botões a mensagem: Anular, Repetir e Ignorar. ABORTRETRYIGNORE = 0x00000002 # Adiciona três botões a mensagem: Cancelar, Tentar e Continuar. CANCELTRYCONTINUE = 0x00000006 # Adiciona o botão de ajuda. HELP = 0x00004000 # Adiciona o botão Ok. SOK = 0x00000000 # Adiciona o botão OK e Cancelar. OKCANCEL = 0x00000001 # Adiciona os botões: Repetir e Cancelar. RETRYCANCEL = 0x00000005 # Adiciona os botões: Sim e Não YESNO = 0x00000004 # Adiciona os botões: Sim, Não e Cancelar YESNOCANCEL = 0x00000003 #-------------------------------------------------------------------------- # • [Constantes] Ícones: #-------------------------------------------------------------------------- # Adiciona um ícone de exclamação ICONEXCLAMATION = 0x00000030 # Adiciona um ícone de informação. ICONINFORMATION = 0x00000040 # Adiciona um ícone de um círculo com um ponto de interrogação. ICONQUESTION = 0x00000020 # Adiciona um íconde parar na mensagem. ICONSTOP = 0x00000010 #-------------------------------------------------------------------------- # • [Constantes] Valores de retorno dos botões: #-------------------------------------------------------------------------- ABORT = 3 # Retorno do valor do botão de Anular CANCEL = 2 # Retorno do valor do botão de Cancelar. CONTINUE = 11 # Retorno do valor do botão de Continuar. IGNORE = 5 # Retorno do valor de ignonar. NO = 7 # Retorno do valor do botão de Não. OK = 1 # Retorno do valor do botão de Ok. RETRY = 4 # Retorno do valor de repetir. TRYAGAIN = 10 # Retorno do valor de Repetir. YES = 6 # Retorno do valor do botão de Sim. #-------------------------------------------------------------------------- # • [Constantes] Valores adicionais. #-------------------------------------------------------------------------- RIGHT = 0x00080000 # Os textos ficarão justificados a direita. TOPMOST = 0x00040000 # O estilo da mensagem é criado como WB_EX_TOPMOST #-------------------------------------------------------------------------- # • [call] : Retorna aos valores dos botões. Para serem usados # como condição, de que se ao clicar. # API::MessageBox.call(title, string, format) # title -> Título da caixa. # string -> Conteúdo da caixa. # format -> Formato, no caso seria os botões e ícones. #-------------------------------------------------------------------------- def call(title, string, format) return FunctionMessageBox.call(API.hWND, API.textUTF(string), API.textUTF(title), format) end #-------------------------------------------------------------------------- # • [messageBox] : Mesma função do Call a diferença é que e protegido. #-------------------------------------------------------------------------- def messageBox(*args) self.call(*args) end protected :messageBox end #============================================================================ # • RTP #============================================================================ module RTP extend self extend API #-------------------------------------------------------------------------- # • Variável & Constante #-------------------------------------------------------------------------- @@rtp = nil DPATH = 'Software\Enterbrain\RGSS3\RTP' DLL = 'Advapi32.dll' #-------------------------------------------------------------------------- # • Retorna ao caminho do diretório do RTP. #-------------------------------------------------------------------------- def path unless @@rtp read_ini = ->(val) { File.foreach("Game.ini") { |line| break($1) if line =~ /^#{val}=(.*)$/ } } key = type = size = [].pack("x4") long("RegOpenKeyEx", [:HKEY, :LPCTST, :DWORD, :REGSAM, :PHKEY], DLL).call( 2147483650, DPATH, 0, 131097, key) key = key.unpack('l').first rtp_data = read_ini["RTP"] long("RegQueryValueEx", [:HKEY, :LPCTSTR, :LPDWORD, :LPDWORD, :LPBYTE, :LPDWORD], DLL).call( key, rtp_data, 0, type, 0, size) buffer = ' '*size.unpack('l').first long("RegQueryValueEx", [:HKEY, :LPCTSTR, :LPDWORD, :LPDWORD, :LPBYTE, :LPDWORD], DLL).call( key, rtp_data, 0, type, buffer, size) long("RegCloseKey", [:HKEY], DLL).call(key) @@rtp = (buffer.gsub(/\\/, '/')).delete!(0.chr) @@rtp += "/" if @@rtp[-1] != "/" end return @@rtp end end #============================================================================ # • ::PNG #============================================================================ module PNG extend self private #-------------------------------------------------------------------------- # • Criar o header do arquivo #-------------------------------------------------------------------------- def make_header(file) # Número mágico file.write([0x89].pack('C')) # PNG file.write([0x50, 0x4E, 0x47].pack('CCC')) # Fim de linha estilo DOS para verificação de conversão DOS - UNIX file.write([0x0D, 0x0A].pack('CC')) # Caractere de fim de linha (DOS) file.write([0x1A].pack('C')) # Caractere de fim de linha (UNIX) file.write([0x0A].pack('C')) end #-------------------------------------------------------------------------- # • Aquisição da soma mágica #-------------------------------------------------------------------------- def checksum(string) Zlib.crc32(string) end #-------------------------------------------------------------------------- # • Criação do chunk de cabeçalho #-------------------------------------------------------------------------- def make_ihdr(bitmap, file) data = '' # Largura data += [bitmap.width, bitmap.height].pack('NN') # Bit depth (???) data += [0x8].pack('C') # Tipo de cor data += [0x6].pack('C') data += [0x0, 0x0, 0x0].pack('CCC') # Tamanho do chunk file.write([data.size].pack('N')) # Tipo de chunk file.write('IHDR') file.write(data) # Soma mágica file.write([checksum('IHDR' + data)].pack('N')) end #-------------------------------------------------------------------------- # • Criação do chunk de dados #-------------------------------------------------------------------------- def make_idat(bitmap, file) data = '' for y in 0...bitmap.height data << "\0" for x in 0...bitmap.width color = bitmap.get_pixel(x, y) data << [color.red, color.green, color.blue, color.alpha].pack('C*') end end # Desinflamento (jeito legal de dizer compressão...) dos dados data = Zlib::Deflate.deflate(data) # Tamanho do chunk file.write([data.size].pack('N')) # Tipo de chunk file.write('IDAT') # Dados (a imagem) file.write(data) # Soma mágica file.write([checksum('IDAT' + data)].pack('N')) end #-------------------------------------------------------------------------- # • Criação do chunk final. #-------------------------------------------------------------------------- def make_iend(file) # Tamanho do chunk file.write([0].pack('N')) # Tipo de chunk file.write('IEND') # Soma mágica file.write([checksum('IEND')].pack('N')) end public #-------------------------------------------------------------------------- # • Salvar : # bitmap : Bitmap. # filename : Nome do arquivo. #-------------------------------------------------------------------------- def save(bitmap, filename) # Verificar se tem a extenção .png filename = filename.include?(".png") ? filename : filename << ".png" # Criação do arquivo file = File.open(filename, 'wb') # Criação do cabeçalho make_header(file) # Criação do primeiro chunk make_ihdr(bitmap, file) # Criação dos dados make_idat(bitmap, file) # Criação do final make_iend(file) file.close end end #============================================================================ # • FindDir #============================================================================ class FindDir #-------------------------------------------------------------------------- # • Variáveis públicas da instâncias. #-------------------------------------------------------------------------- attr_accessor :dir attr_accessor :files attr_accessor :folders attr_accessor :type #-------------------------------------------------------------------------- # • Diretórios principais. #-------------------------------------------------------------------------- def self.env env = ENV['USERPROFILE'].gsub("\\", "/") return { desktop: env + "/Desktop", # Desktop diretório. recent: env + "/Recent", # Recent diretório. drive: ENV["HOMEDRIVE"], # Diretório do Drive. doc: env + "/Documents", # Diretório dos documento. current: Dir.getwd, # Diretório da atual. } end #-------------------------------------------------------------------------- # • Inicialização dos objetos. #-------------------------------------------------------------------------- def initialize(direction=Dir.getwd) @dir = String(direction) @files = [] @folders = [] setup end #-------------------------------------------------------------------------- # • Configuração. #-------------------------------------------------------------------------- def setup @files = [] @folders = [] for data in Dir[@dir+"/*"] if FileTest.directory?(data) @folders << data else @files << data end end end #-------------------------------------------------------------------------- # • Todos os arquivos. #-------------------------------------------------------------------------- def all_files @folders + @files end #-------------------------------------------------------------------------- # • Mover para outro diretório. #-------------------------------------------------------------------------- def move_to(dir) @dir = File.expand_path(@dir + "/#{dir}") setup end #-------------------------------------------------------------------------- # • Mover para os diretórios principais. #-------------------------------------------------------------------------- def move_to_dir(sym) @dir = API::FindDir.env.get(sym) setup end def ret @dir != API::FindDir.env.get(:drive) end end #============================================================================ # • Network #============================================================================ module Network include API extend self #-------------------------------------------------------------------------- # • [InternetGetConnectedState] : Verifica o estado de conexão da internet. #-------------------------------------------------------------------------- InternetGetConnectedState = int("InternetGetConnectedState", [:LPDWORD, :DWORD], "wininet.dll") #-------------------------------------------------------------------------- # • [URLDownloadToFile] : Baixa um arquivo direto de um link da internet. #-------------------------------------------------------------------------- URLDownloadToFile = int("URLDownloadToFile", [:LPCTSTR, :LPCTSTR, :LPCTSTR, :int, :int], "urlmon.dll") #-------------------------------------------------------------------------- # • Verificar a conexão com internet. #-------------------------------------------------------------------------- def connected? InternetGetConnectedState.call(' ', 0) == 0x01 end #-------------------------------------------------------------------------- # • Baixar um arquivo direto de um link. # url : Link do arquivo. # dest : Pasta de destino. # open : Abrir o arquivo ao terminar de baixar. # # • Example: # url = "http://www.news2news.com/vfp/downloads/w32data.zip" # dstfile = "w32data.zip" # URLDownloadToFile.run(url, dstfile) #-------------------------------------------------------------------------- def link_download(url, dest, open = false) return unless connected? hresult = URLDownloadToFile.call(NIL, url, dest, 0, 0) if (hresult == 0) return true unless open Shellxecute.call(nil, "open", dest, nil, nil, 1) return true else raise("URLDownloadToFile call failed: %X\n", hresult) end end end protected :hwnd, :open, :function end } #============================================================================== # * String #============================================================================== Dax.register(:string, "dax", 2.0) { class String #---------------------------------------------------------------------------- # • [String] : Remove a extensão do nome do arquivo e assume por outra. # filename : Nome do aquivo. # extension : Nova extensão. # "Hello.rb".extn(".rvdata2") # "Hello.rvdata2" #---------------------------------------------------------------------------- def extn(extension) return self.gsub(/\.(\w+)/, extension.include?(".") ? extension : "." + extension) end #-------------------------------------------------------------------------- # • [String] : converter à String em UTF8 #-------------------------------------------------------------------------- def to_utf8 API.textUTF(self) end #---------------------------------------------------------------------------- # • [String] : Converter a String para w_char. Pra chamadas WinAPI. #---------------------------------------------------------------------------- def w_char wstr = "" self.size.times { |i| wstr += self[i, 1] + "\0" } wstr += "\0" return wstr end #-------------------------------------------------------------------------- # • [Array] : Extrai somente os números da String, e retorna a uma Array. # Exemplo: "João89".numbers # [8, 9] #-------------------------------------------------------------------------- def numbers self.scan(/-*\d+/).collect{|n|n.to_i} end alias :num :numbers #---------------------------------------------------------------------------- # • [String] : Aplicando Case Sensitive # "Exemplo 2" => "Exemplo_2" #---------------------------------------------------------------------------- def case_sensitive return self.gsub(" ", "_") end #---------------------------------------------------------------------------- # • [Symbol] : Transforma em símbolo a string. # "Ola Meu Nome É" #:ola_menu_nome_é #---------------------------------------------------------------------------- def symbol return self.case_sensitive.downcase.to_sym end #---------------------------------------------------------------------------- # • [String] : Remove o último caractere da String. #---------------------------------------------------------------------------- def backslash return String(self[0, self.split(//).size-1]) end #---------------------------------------------------------------------------- # • Método xor. #---------------------------------------------------------------------------- def ^(string) bytes.map.with_index{|byte, index| byte ^ other[index % other.size].ord }.pack("C*") end alias xor ^ end } #============================================================================== # * Integer #============================================================================== Dax.register(:integer, "dax", 2.5) { class Integer #---------------------------------------------------------------------------- # • [TrueClass/FalseClass] : Verifica-se e par. #---------------------------------------------------------------------------- def is_evan? return (self & 1) == 0 end #---------------------------------------------------------------------------- # • [TrueClass/FalseClass] : Verifica-se e impar. #---------------------------------------------------------------------------- def is_odd? return (self & 1) == 1 end #---------------------------------------------------------------------------- # • [Integer] : Aumenta o valor até chegar ao máximo(definido), quando # chegar ao máximo(definido) retorna a zero(pode definir). # back : Valor de retorno. # max : Valor máximo. # compare : Método de comparação #---------------------------------------------------------------------------- def up(back, max, compare=:>) return (self.method(compare).call(max) ? back : (self + 1)) end #---------------------------------------------------------------------------- # • [Integer] : Diminui o valor até chegar a zero, quando chegar a zero(pode definir) # retorna ao valor máximo(defindo). # back : Valor de retorno. # max : Valor máximo. # compare : Método de comparação #---------------------------------------------------------------------------- def down(max, r=0, compare=:<) return (self.method(compare).call(back) ? max : (self - 1)) end #---------------------------------------------------------------------------- # • [Integer] : Formula de número randômico. #---------------------------------------------------------------------------- def aleatory return ((1..(self.abs)).to_a).shuffle[rand(self).to_i].to_i end end } #============================================================================== # • Numeric #============================================================================== Dax.register(:numeric, "dax", 2.0) { class Numeric #---------------------------------------------------------------------------- # * [Numeric] : Transformar em porcentagem # a : Valor atual. # b : Valor máximo. #---------------------------------------------------------------------------- def to_p(a, b) self * a / b end alias :percent :to_p #---------------------------------------------------------------------------- # • [Numeric] : Pega um do porcento. # max : Valor máximo. #---------------------------------------------------------------------------- def p_to(max) (self * max) / 100 end alias :proportion :p_to #---------------------------------------------------------------------------- # * [Numeric] : Variação do número. # x : Variação total. [-x, x] #---------------------------------------------------------------------------- def randomic(x=4) return ( (self+rand(2)) + (self + (rand(2) == 0 ? rand(x) : -rand(x)) ) ) / 2 end #---------------------------------------------------------------------------- # * [Boolean] : Verifica se o número é igual a um dos especificados. # 1.equal?(2, 3) # false #---------------------------------------------------------------------------- def equal?(*args) args.each { |i| self == i ? (return true) : next } return false end end } #============================================================================== # • Position. #============================================================================== Dax.register(:position, "dax", 3.0) { class Position #---------------------------------------------------------------------------- # • Modificar a posição de um objeto, que deve de conter as variáveis # x, y, width, height. # pos : Defina aqui o valor que definirá a posição da escola. Veja abaixo # object : Objeto que contenha as variáveis x, y, width, height. # os valores. # 0 : Ficará no canto esquerdo superior. # 1 : Posição X mudará para o centro da tela. # 2 : Ficará no canto direito superior. # 3 : Ficará no canto esquerdo inferior. # 4 : Posição Y mudará para o centro da tela. # 5 : Ficará no canto direito inferior. # :center : Mudar a posição para o centro da tela. # :center_left : Centralizar à esquerda da tela. # :center_right : Centralizar à direita da tela. # :center_up : Centralizar no centro superior. # :center_down : Centralizar no centro inferior. #---------------------------------------------------------------------------- def self.[](pos, object) return if object.nil? or pos.nil? return object.x, object.y = pos[0], pos[1] if pos.is_a?(Array) return object.x, object.y = pos.x, pos.y if pos.is_a?(Position) case pos when 0 then object.x, object.y = 0, 0 when 1 then object.x = DMath.get_x_center_screen(object.width) when 2 then object.x, object.y = Graphics.width - object.width, 0 when 3 then object.x, object.y = 0, Graphics.height - object.height when 4 then object.y = DMath.get_y_center_screen(object.height) when 5 then object.x, object.y = Graphics.width - object.width, Graphics.height - object.height when :center object.x = (Graphics.width - object.width) / 2 object.y = (Graphics.height - object.height) / 2 when :center_left object.x = 0 object.y = (Graphics.height - object.height) / 2 when :center_right object.x = Graphics.width - object.width object.y = (Graphics.height - object.height) / 2 when :center_up object.x = (Graphics.width - object.width) / 2 object.y = 0 when :center_down object.x = (Graphics.width - object.width) / 2 object.y = Graphics.height - object.height end end #---------------------------------------------------------------------------- # • Variáveis públicas da instância. #---------------------------------------------------------------------------- attr_accessor :x # Variável que retorna ao valor que indica a posição X. attr_accessor :y # Variável que retorna ao valor que indica a posição Y. #---------------------------------------------------------------------------- # • Inicialização dos objetos. #---------------------------------------------------------------------------- def initialize(x, y) @x = x || 0 @y = y || 0 end #---------------------------------------------------------------------------- # • Somar com outra posição. #---------------------------------------------------------------------------- def +(position) position = position.position unless position.is_a?(Position) Position.new(self.x + position.x, self.y + position.y) end #---------------------------------------------------------------------------- # • Subtrair com outra posição. #---------------------------------------------------------------------------- def -(position) position = position.position unless position.is_a?(Position) Position.new(self.x - position.x, self.y - position.y) end #---------------------------------------------------------------------------- # • Multiplicar com outra posição. #---------------------------------------------------------------------------- def *(position) position = position.position unless position.is_a?(Position) Position.new(self.x * position.x, self.y * position.y) end #---------------------------------------------------------------------------- # • Dividir com outra posição. #---------------------------------------------------------------------------- def /(position) position = position.position unless position.is_a?(Position) return if (self.x or position.x or self.y or position.y) <= 0 Position.new(self.x / position.x, self.y / position.y) end #---------------------------------------------------------------------------- # • Comparar com outra posição. #---------------------------------------------------------------------------- def ==(position) position = position.position unless position.is_a?(Position) return self.x == position.x && self.y == position.y end #---------------------------------------------------------------------------- # • Distância de um ponto de posição com relação a outro. # other : Outro ponto de posição. #---------------------------------------------------------------------------- def distance(other) other = other.position unless other.is_a?(Position) (self.x - other.x).abs + (self.y - other.y).abs end #---------------------------------------------------------------------------- # • Converter em string. #---------------------------------------------------------------------------- def to_s(broken="\n") return "position x: #{self.x}#{broken}position y: #{self.y}" end #---------------------------------------------------------------------------- # • Converter em array. #---------------------------------------------------------------------------- def to_a return [@x, @y] end #---------------------------------------------------------------------------- # • Converter em hash. #---------------------------------------------------------------------------- def to_h return {x: @x, y: @y} end #---------------------------------------------------------------------------- # • Clonar #---------------------------------------------------------------------------- def clone return Position.new(@x, @y) end end } #============================================================================== # • File #============================================================================== Dax.register(:file, "dax", 1.0) { class << File #---------------------------------------------------------------------------- # • [NilClass] : Executa o script que está no arquivo. #---------------------------------------------------------------------------- def eval(filename) return unless filename.match(/.rb|.rvdata2/) or FileTest.exist?(filename) script = "" nilcommand = false IO.readlines(filename).each { |i| if i.match(/^=begin/) nilcommand = true elsif i.match(/^=end/) and nilcommand nilcommand = false elsif !nilcommand script += i.gsub(/#(.*)/, "").to_s + "\n" end } Kernel.eval(script) return nil end end } #============================================================================== # • Dir #============================================================================== Dax.register(:dir, "dax", 1.0) { class << Dir #---------------------------------------------------------------------------- # • [NilClass] Cria pasta e subpasta em conjunto. # Separe todo com vírgulas. A primeira que você definir será a pasta, # o resto será as subpasta. # Dir.mksdir("Pasta", "Subpasta1, Subpasta2") #---------------------------------------------------------------------------- def mksdir(dir="", subdir="") self.mkdir(dir) unless File.directory?(dir) subdir = subdir.split(/,/) subdir.each { |data| self.mkdir(dir + "/" + data.strip) unless File.directory?(dir + "/" + data.gsub(" ", "")) } return nil end end } #============================================================================== # * Color #============================================================================== Dax.register(:color, "dax", 3.5) { class Color #---------------------------------------------------------------------------- # • [Color] : Permite você modificar a opacidade da cor. # Color.new(r, g, b).opacity([alpha]) # O valor padrão do alpha e 128.. não é preciso espeficar. #---------------------------------------------------------------------------- def opacity(alpha=nil) self.set(self.red, self.green, self.blue, alpha || 128) end #---------------------------------------------------------------------------- # • [Color] : Inverte as cores. # Color.new(r, g, b[, a).invert! #---------------------------------------------------------------------------- def invert! self.set(255-self.red, 255-self.green, 255-self.blue, self.alpha) end #---------------------------------------------------------------------------- # • [Color] : Reverte as cores. # Color.new(r, g, b[, a).revert #---------------------------------------------------------------------------- def revert self.set(*[self.red, self.green, self.blue, self.alpha].reverse!) end #---------------------------------------------------------------------------- # • [String] : Converte para string as informações dos valores das cores. # Color.new(0, 0, 0).to_s # red: 0 # blue: 0 # green: 0 # alpha: 255 #---------------------------------------------------------------------------- def to_s "red: #{self.red}\nblue: #{self.blue}\ngreen: #{self.green}\nalpha: #{self.alpha}" end #---------------------------------------------------------------------------- # • [TrueClass/FalseClass] : Comparar cores, retorna a [true] se for igual.. # retorna a [false] se não for igual. #---------------------------------------------------------------------------- def ==(color) return (self.red == color.red and self.green == color.green and self.blue == color.blue and self.alpha == color.alpha) ? true : false end #---------------------------------------------------------------------------- # • [Hash] : Retorna aos valores das cores em formato de Hash. # Color.new(0, 0, 0).to_h # {:red => 0, :green => 0, :blue => 0, :alpha => 255} #---------------------------------------------------------------------------- def to_h return { red: self.red, green: self.green, blue: self.blue, alpha: self.alpha, } end #---------------------------------------------------------------------------- # • [Array] : Retorna aos valores das cores em formato de Array. # includeAlpha : Incluir o valor alpha? # Color.new(0, 0, 0).to_a # [0, 0, 0, 255] #---------------------------------------------------------------------------- def to_a(includeAlpha=false) array = [self.red, self.green, self.blue] array += [self.alpha] if includeAlpha return array end #---------------------------------------------------------------------------- # • [Color] : Dispoem os valores das cores em ordem crescente e cria uma # nova cor. # includeAlpha : Incluir o valor alpha? #---------------------------------------------------------------------------- def crescent(includeAlpha=false) set(*to_a(includeAlpha).crescent) end #---------------------------------------------------------------------------- # • [Color] : Dispoem os valores das cores em ordem decrescente e cria uma # nova cor. # includeAlpha : Incluir o valor alpha? #---------------------------------------------------------------------------- def decrescent(includeAlpha=false) set(*to_a(includeAlpha).decrescent) end #---------------------------------------------------------------------------- # • [Color] Soma os valores das cores com os valores de outras cores. # Ex: color + Color.new(21,54,255) #---------------------------------------------------------------------------- def +(color) return unless color.is_a?(Color) self.set( *color.to_a(false).each_with_index { |i, n| i + to_a[n] } ) end #---------------------------------------------------------------------------- # • [Color] Subtrai os valores das cores com os valores de outras cores. # Ex: color - Color.new(21,54,255) #---------------------------------------------------------------------------- def -(color) return unless color.is_a?(Color) self.set( *color.to_a(false).each_with_index { |i, n| i - to_a[n] } ) end #---------------------------------------------------------------------------- # • [Color] Multiplica os valores das cores com os valores de outras cores. # Ex: color * Color.new(21,54,255) #---------------------------------------------------------------------------- def *(color) return unless color.is_a?(Color) self.set( *color.to_a(false).each_with_index { |i, n| (i * to_a[n]) / 255.0 } ) end #---------------------------------------------------------------------------- # • [Color] Divide os valores das cores com os valores de outras cores. # Ex: color / Color.new(21,54,255) #---------------------------------------------------------------------------- def /(color) return unless color.is_a?(Color) self.set( *color.to_a(false).each_with_index { |i, n| i.zero? ? 0 : to_a[n] / i } ) end #---------------------------------------------------------------------------- # • [Color] : Aumentar/Diminuir as cores em porcento. # value : Valor da porcentagem. Vai de 0~100 # includeAlpha : Incluir o valor alpha? #---------------------------------------------------------------------------- def percent(value, includeAlpha=true) value = DMath.clamp(value, 0, 100) Color.new( *to_a(includeAlpha).collect! { |i| i.to_p(value * 2.55, 255) } ) end #---------------------------------------------------------------------------- # • [Numeric] : Retorna a lumonisidade das cores. #---------------------------------------------------------------------------- def luminosity return to_a(false).each_with_index { |i, n| i * [0.21, 0.71, 0.07][n] }.alln? end #---------------------------------------------------------------------------- # • [Numeric] : Retorna a media entre os valores(canais). # includeAlpha : Incluir o valor alpha? #---------------------------------------------------------------------------- def avarange(includeAlpha=true) n = includeAlpha ? 4 : 3 return to_a(includeAlpha).alln? / n end #---------------------------------------------------------------------------- # • [Numeric] : Retorna ao valor mais alto que tiver, dentre os valores # especificados das cores. #---------------------------------------------------------------------------- def max [red, green, blue].max end #---------------------------------------------------------------------------- # • [Numeric] : Retorna ao valor menor que tiver, dentre os valores # especificados das cores. #---------------------------------------------------------------------------- def min [red, green, blue].min end #---------------------------------------------------------------------------- # • [Color] : Define uma cor aleatória: # Exemplo: Color.new.random #---------------------------------------------------------------------------- def random return Color.new(rand(256), rand(256), rand(256)) end #---------------------------------------------------------------------------- # • [Color] : Define uma cor em hexadécimal. # Exemplo : Color.new.hex("ffffff") #---------------------------------------------------------------------------- def hex(string) self.set(*string.scan(/../).map { |color| color.to_i(16)}) end #---------------------------------------------------------------------------- # • [Color] : Retorna a cor padrão. # Exemplo : Color.new.default #---------------------------------------------------------------------------- def default self.hex("ffffff") end end } #============================================================================== # • Rect #============================================================================== Dax.register(:rect, "dax & gab!", 1.5) { class Rect #---------------------------------------------------------------------------- # • [TrueClass/FalseClass] : Verificar se algo está na área. #---------------------------------------------------------------------------- def in?(x, y) x.between?(self.x, self.x + self.width) && y.between?(self.y, self.y + self.height) end #---------------------------------------------------------------------------- # • [NilClass] : Retorna a cada parte do rect definida por ti, ponto-a-ponto. # p : Ponto A. # q : Ponto B. # Rect.new(0, 0, 1, 1).step(1.0, 1.0) { |i, j| p [i, j] } # [0.0, 0.0] # [0.0, 1.0] # [1.0, 0.0] # [1.0, 1.0] #---------------------------------------------------------------------------- def step(p=1, q=1) (self.x..(self.x + self.width)).step(p) { |i| (self.y..(self.y + self.height)).step(q) { |j| yield(i, j) } } return nil end #---------------------------------------------------------------------------- # • [Array] : Retorna aos valores do Rect em uma Array. #---------------------------------------------------------------------------- def to_a return [self.x, self.y, self.width, self.height] end #---------------------------------------------------------------------------- # • Retorna interseção com o argumento, que deve ser também do tipo Rect #---------------------------------------------------------------------------- def intercept(rect) x = [self.x, rect.x].max y = [self.y, rect.y].max w = [self.x + self.width, rect.x + rect.width ].min - x h = [self.y + self.height, rect.y + rect.height].min - y return Rect.new(x, y, w, h) end alias & intercept end } #============================================================================== # • DMath #============================================================================== Dax.register(:dmath, 'Dax', 4.0) { module DMath extend self #---------------------------------------------------------------------------- # • Constantes para fórmula de dano. #---------------------------------------------------------------------------- MAX_VALUE_PARAM = 256 MAX_VALUE_PARAM_AXE = 128 MAX_VALUE_PARAM_DAGGER = 218 MAX_VALUE_PARAM_GUN = 99 MAX_VALUE_MAGIC = 218 #---------------------------------------------------------------------------- # • [Numeric] : Calcula o ângulo entre dóis pontos. #---------------------------------------------------------------------------- def angle(pA, pB, quad4=false) pA = pA.position unless pA.is_a?(Position) pB = pB.position unless pB.is_a?(Position) x = pB.x - pA.x y = pB.y - pA.y y *= -1 if quad4 radian = Math.atan2(y, x) angle = (radian * 180 / Math::PI) angle = 360 + angle if angle < 0 return angle end #---------------------------------------------------------------------------- # • [Boolean] : Verifica se a posição é igual. #---------------------------------------------------------------------------- def equal_pos?(a, b) (a.x == b.x) && (a.y == b.y) end #---------------------------------------------------------------------------- # • [Float] : Cálcula a raíz quadrada que qualquer grau. # n : Número que será calculado. # g : Grau da raíz. # Dmath.sqrt(27, 3) # Cálculo da raíz cúbica de 27 => 3.0 #---------------------------------------------------------------------------- def sqrt(n, g) raise(ArgumentError) if n < 0 && n.is_evan? x, count, num = 1.0, 0.0, 0.0 while num = x - ( ( x ** g - n ) / ( g * ( x ** g.pred ) ) ) (x == num) || (count > 20) ? break : eval("x = num; count += 1") end return num end #---------------------------------------------------------------------------- # • [Numeric] : Clamp | Delimitar o inteiro # num : Número. # low : Número minímo. Sê o 'num' for menor que min retorna a low. # high : Número máximo. Sê o 'num' for maior que hight retorna a high, caso # não retorna ao próprio número(num). #---------------------------------------------------------------------------- def clamp(num, low, high) num, low, high = num.to_i, low.to_i, high.to_i num = num < low ? low : num > high ? high : num num end #---------------------------------------------------------------------------- # • [Array] : Centralizar um objeto n'outro. # object : Objeto, tem que ser do tipo [Sprite] ou [Window_Base] # object_for_centralize : Objeto que irá se centralizar no 'object', tem # que ser do tipo [Sprite] ou [Window_Base] # * Retorna a uma Array contendo as informações das novas posições em X e Y. #---------------------------------------------------------------------------- def centralize_object(object, object_for_centralize) x = object.x + (object.width - object_for_centralize.width) / 2 y = object.y + (object.height - object_for_centralize.height) / 2 return x, y end #---------------------------------------------------------------------------- # • [Numeric] : Centralizar um objeto n'outro, obtendo somente a posição X. # objectx : Valor da posição X do objeto número 1. # objectwidth : Valor da largura do objeto número 1. # object_for_centralizewidth : Valor da largura do objeto que irá se # centralizar no objeto número 1. # * Retorna ao valor da posição X. #---------------------------------------------------------------------------- def centralize_x(objectx, objectwidth, object_for_centralizewidth) return objectx + (objectwidth - object_for_centralizewidth) / 2 end #---------------------------------------------------------------------------- # • [Numeric] : Centralizar um objeto n'outro, obtendo somente a posição Y. # objecty : Valor da posição Y do objeto número 1. # objectheight : Valor da altura do objeto número 1. # object_for_centralizeheight : Valor da altura do objeto que irá se # centralizar no objeto número 1. # * Retorna ao valor da posição Y. #---------------------------------------------------------------------------- def centralize_y(objecty, objectheight, object_for_centralizeheight) return objecty + (objectheight - object_for_centralizeheight) / 2 end #---------------------------------------------------------------------------- # • [Numeric] : Obter a posição X do centro da tela referente a largura do objeto X. # Exemplo: get_x_center_screen(sprite.width) : Irá retornar ao valor da posição # X para que o objeto fique no centro da tela. # Exemplo: sprite.x = get_x_center_screen(sprite.width) #---------------------------------------------------------------------------- def get_x_center_screen(width) return (Graphics.width - width) / 2 end #---------------------------------------------------------------------------- # • [Numeric] : Obter a posição Y do centro da tela referente a altura do objeto X. # Exemplo: get_y_center_screen(sprite.height) : Irá retornar ao valor da posição # Y para que o objeto fique no centro da tela. # Exemplo: sprite.y = get_y_center_screen(sprite.height) #---------------------------------------------------------------------------- def get_y_center_screen(height) return (Graphics.height - height) / 2 end #-------------------------------------------------------------------------- # • [TrueClass/FalseClass] : Verifica se um objeto está na área de um círculo. # object : Objeto do tipo da classe [Sprite]. # object2 : Objeto do tipo da classe [Sprite]. # size : Tamanho geral do círculo. #-------------------------------------------------------------------------- def circle(object, object2, size) ( (object.x - object2.x) ** 2) + ( (object.y - object2.y) ** 2) <= (size ** 2) end #---------------------------------------------------------------------------- # • [Numeric] : Converter o valor em graus. #---------------------------------------------------------------------------- def graus 360 / (2 * Math::PI) end #---------------------------------------------------------------------------- # • [Numeric] : Converte o valor em radiano. #---------------------------------------------------------------------------- def radian(degree) return (degree.to_f/180) * Math::PI end #---------------------------------------------------------------------------- # • [Numeric] : Converte o valor em grau. #---------------------------------------------------------------------------- def degree(radian) return (radian.to_f/Math::PI) * 180 end #---------------------------------------------------------------------------- # • [Numeric] : Retorna pra base de 4 decimais. #---------------------------------------------------------------------------- def to_4_dec(n) ((n * 1000).ceil) / 1000 end #---------------------------------------------------------------------------- # • [Numeric] : Retorna a área do triângulo. # x : x : Posição x do ponto 1 # y : Posição y do ponto 1 # x2 : Posição x do ponto 2 # y2 : Posição y do ponto 2 # x3 : Posição x do ponto 3 # y3 : Posição y do ponto 3 #---------------------------------------------------------------------------- def triangle_area(*args) x, y, x2, y2, x3, y3 = *args return (x2 - x) * (y3 - y) - (x3 - x) * (y2 - y) end #---------------------------------------------------------------------------- # • [Numeric] : Método para calcular a distância de um objeto para com outro. #---------------------------------------------------------------------------- def distance_sensor(target, target2) return (target.x - target2.x).abs + (target.y - target2.y).abs end #---------------------------------------------------------------------------- # • [Integer] : Método euclidiano para mediar a distância de um ponto # para outro ponto. Primeira dimensão. # p : Ponto A. [x, y] # q : Ponto B. [x, y] # euclidean_distance_1d(5, 1) #4 #---------------------------------------------------------------------------- def euclidean_distance_1d(p, q) return sqrt( (p - q) ** 2, 2 ).floor end #---------------------------------------------------------------------------- # • [Integer] : Método euclidiano para mediar a distância de um ponto # para outro ponto. Segunda dimensão. # p : Ponto A. [x, y] # q : Ponto B. [x, y] # euclidean_distance_2d([1, 3], [1, 5]) #2 #---------------------------------------------------------------------------- def euclidean_distance_2d(p, q) p = p.position unless p.is_a?(Position) q = q.position unless q.is_a?(Position) return sqrt( ((p.x - q.x) ** 2) + ((p.y - q.y) ** 2), 2 ).floor end #---------------------------------------------------------------------------- # • [Numeric] : Dentro do círculo. #---------------------------------------------------------------------------- def circle_in(t, b, c, d) return -c * (Math.sqrt(1 - (t /= d.to_f) * t) - 1) + b end #---------------------------------------------------------------------------- # • [Numeric] : Fora do círculo #---------------------------------------------------------------------------- def circle_out(t, b, c, d) return c * Math.sqrt(1 - (t=t/d.to_f-1)*t) + b end #---------------------------------------------------------------------------- # • [Numeric] : Retorna ao valor minímo, do valor máximo de min & v, com o # valor de max. #---------------------------------------------------------------------------- def force_range(v, min, max) [[min, v].max, max].min end #---------------------------------------------------------------------------- # • Cálculo de variação para o dano. Para equilibrar. #---------------------------------------------------------------------------- def random (1 + 2.aleatory) ** 0.125 end #---------------------------------------------------------------------------- # • Resultado final. #---------------------------------------------------------------------------- def lastResult(x) return x <= 0 ? 0 : x.round end #---------------------------------------------------------------------------- # • [Formula de dano] : Espadas(1 & 2 mão), lanças, bestas, cajado. #---------------------------------------------------------------------------- def sword(attack, strength, defense, level) str = strength.randomic return lastResult((attack.randomic * random - defense.randomic) * (1 + str * (level + str) / MAX_VALUE_PARAM)) end #---------------------------------------------------------------------------- # • [Formula de dano] : Desarmado. #---------------------------------------------------------------------------- def unarmed(strength, defense, level) str = strength.randomic lastResult((11 * random - defense.randomic) * str * (level + str) / MAX_VALUE_PARAM) end #---------------------------------------------------------------------------- # • [Formula de dano] : Desarmado com luva. #---------------------------------------------------------------------------- def unarmed_brawler(strength, defense, level) str = strength.randomic lastResult(((level + str) / 2 * random - defense.randomic) * str * (level + str) / MAX_VALUE_PARAM) end #---------------------------------------------------------------------------- # • [Formula de dano] : Cajado de mágia. #---------------------------------------------------------------------------- def pole(attack, strength, defense, level, magicDefense) str = strength.randomic lastResult((attack.randomic * random - magicDefense.randomic) * (1 + str * (level + str))/ MAX_VALUE_PARAM) end #---------------------------------------------------------------------------- # • [Formula de dano] : Maças.. #---------------------------------------------------------------------------- def mace(attack, defense, magic, level) mag = magic.randomic lastResult((attack.randomic * random - defense.randomic) * (1 + mag * (level + mag)) / MAX_VALUE_PARAM) end #---------------------------------------------------------------------------- # • [Formula de dano] : Katanas, staves.. #---------------------------------------------------------------------------- def katana(attack, defense, strength, magic, level) lastResult((attack.randomic * random - defense.randomic) * (1 + strength.randomic * (level + magic.randomic) / MAX_VALUE_PARAM)) end #---------------------------------------------------------------------------- # • [Formula de dano] : Machados, marretas.. #---------------------------------------------------------------------------- def axe(attack, strength, defense, level, vitality) lastResult((attack.randomic * random - defense.randomic) * (1 + strength.randomic * (level+vitality.randomic)/MAX_VALUE_PARAM_AXE)) end #---------------------------------------------------------------------------- # • [Formula de dano] : Adagas, espadas ninjas e arco.. #---------------------------------------------------------------------------- def dagger(attack, defense, strength, level, speed) lastResult ((attack.randomic * random) - defense.randomic) * (1 + strength.randomic * (level + speed.randomic) / 218) end #---------------------------------------------------------------------------- # • [Formula de dano] : Revolvers #---------------------------------------------------------------------------- def gun(attack,defense,strength, level) str = strength.randomic lastResult ( (((attack.randomic * random) - defense.randomic) ** 2) / 64 ) * (1 + str * (level + str) / MAX_VALUE_PARAM_GUN) end #---------------------------------------------------------------------------- # • [Formula de dano] : Mágicas de ataques. #---------------------------------------------------------------------------- def magicAttack(magicDefense, level, magicAttack, attackMagic) mag = magicAttack.randomic lastResult ( (attackMagic.randomic * random) - magicDefense.randomic ) * (2 + mag.randomic * (level + mag) / MAX_VALUE_MAGIC) end #---------------------------------------------------------------------------- # • [Formula de dano] : Mágicas de cura; #---------------------------------------------------------------------------- def magicHeal(strengthMagic, magicAttack, level) mag = magicAttack.randomic lastResult (strengthMagic * random) * (2 + mag * (level + mag) / MAX_VALUE_MAGIC) end #---------------------------------------------------------------------------- # • [Formula de EXP] : Gerador de curva de exp. # minlv : Level minimo. # maxlv : Level máximo. # stvalue : Valor inicial. # infl : Inflação. #---------------------------------------------------------------------------- def generate_curve_exp(minlv, maxlv, stvalue, infl) table = [] (minlv..maxlv).each { |i| table[i] = (stvalue + (infl + (Random.new.rand(infl..(infl+i)).to_i % i )) * i).to_i.round} table end end } #============================================================================== # • Keyboard | Método para usar todas as teclas do teclado. #============================================================================== Dax.register(:key, "Dax", 2.0) { module Key #---------------------------------------------------------------------------- # • Extensão & Variáveis da instância do módulo. #---------------------------------------------------------------------------- extend self attr_accessor :_cacheText # Armazena os textos. #---------------------------------------------------------------------------- # • Texto do cache #---------------------------------------------------------------------------- def text return @_cacheText end alias :to_s :text #---------------------------------------------------------------------------- # • Chaves. #---------------------------------------------------------------------------- KEY = { # Chaves diversas. CANCEL: 0x03, BACKSPACE: 0x08, TAB: 0x09, CLEAR: 0x0C, ENTER: 0x0D, SHIFT: 0x10, CONTROL: 0x11, MENU: 0x12, PAUSE: 0x13, ESC: 0x1B, CONVERT: 0x1C, NONCONVERT: 0x1D, ACCEPT: 0x1E, SPACE: 0x20, PRIOR: 0x21, NEXT: 0x22, ENDS: 0x23, HOME: 0x24, LEFT: 0x25, UP: 0x26, RIGHT: 0x27, DOWN: 0x28, SELECT: 0x29, PRINT: 0x2A, EXECUTE: 0x2B, SNAPSHOT: 0x2C, DELETE: 0x2E, HELP: 0x2F, LSHIFT: 0xA0, RSHIFT: 0xA1, LCONTROL: 0xA2, RCONTROL: 0xA3, LALT: 0xA4, RALT: 0xA5, PACKET: 0xE7, # MOUSE MOUSE_RIGHT: 0x01, MOUSE_LEFT: 0x02, MOUSE_MIDDLE: 0x04, X1: 0x05, X2: 0x06, # Chaves de números. N0: 0x30, N1: 0x31, N2: 0x32, N3: 0x33, N4: 0x34, N5: 0x35, N6: 0x36, N7: 0x37, N8: 0x38, N9: 0x39, # Chaves de letras. A: 0x41, B: 0x42, C: 0x43, D: 0x44, E: 0x45, F: 0x46, G: 0x47, H: 0x48, I: 0x49, J: 0x4A, K: 0x4B, L: 0x4C, M: 0x4D, N: 0x4E, O: 0x4F, P: 0x50, Q: 0x51, R: 0x52, S: 0x53, T: 0x54, U: 0x55, V: 0x56, W: 0x57, X: 0x58, Y: 0x59, Z: 0x5A, Ç: 0xBA, # Chaves do window. LWIN: 0x5B, RWIN: 0x5C, APPS: 0x5D, SLEEP: 0x5F, BROWSER_BACK: 0xA6, BROWSER_FORWARD: 0xA7, BROWSER_REFRESH: 0xA8, BROWSER_STOP: 0xA9, BROWSER_SEARCH: 0xAA, BROWSER_FAVORITES: 0xAB, BROWSER_HOME: 0xAC, VOLUME_MUTE: 0xAD, VOLUME_DOWN: 0xAE, VOLUME_UP: 0xAF, MEDIA_NEXT_TRACK: 0xB0, MEDIA_PREV_TRACK: 0xB1, MEDIA_STOP: 0xB2, MEDIA_PLAY_PAUSE: 0xB3, LAUNCH_MAIL: 0xB4, LAUNCH_MEDIA_SELECT: 0xB5, LAUNCH_APP1: 0xB6, LAUNCH_APP2: 0xB7, PROCESSKEY: 0xE5, ATIN: 0xF6, CRSEL: 0xF7, EXSEL: 0xF8, EREOF: 0xF9, PLAY: 0xFA, ZOOM: 0xFB, PA1: 0xFD, # Chaves do NUMPAD NUMPAD0: 0x60, NUMPAD1: 0x61, NUMPAD2: 0x62, NUMPAD3: 0x63, NUMPAD4: 0x64, NUMPAD5: 0x65, NUMPAD6: 0x66, NUMPAD7: 0x67, NUMPAD8: 0x68, NUMPAD9: 0x69, MULTIPLY: 0x6A, ADD: 0x6B, SEPARATOR: 0x6C, SUBTRACT: 0x6D, DECIMAL: 0x6E, DIVIDE: 0x6F, # Caches de função. F1: 0x70, F2: 0x71, F3: 0x72, F4: 0x73, F5: 0x74, F6: 0x75, F7: 0x76, F8: 0x77, F9: 0x78, F10: 0x79, F11: 0x7A, F12: 0x7B, F13: 0x7C, F14: 0x7D, F15: 0x7E, F16: 0x7F, F17: 0x80, F18: 0x81, F19: 0x82, F20: 0x83, F21: 0x84, F22: 0x85, F23: 0x86, F24: 0x87, # Chaves alternativas. CAPS: 0x14, INSERT: 0x2D, NUMLOCK: 0x90, SCROLL: 0x91, # Chaves OEM, variadas. OEM_1: 0xC1, OEM_PLUS: 0xBB, OEM_COMMA: 0xBC, OEM_MINUS: 0xBD, OEM_PERIOD: 0xBE, OEM_2: 0xBF, QUOTE: 0xC0, ACCUTE: 0xDB, OEM_6: 0xDD, OEM_7: 0xDC, TIL: 0xDE, OEM_102: 0xE2, OEM_CLEAR: 0xFE, } #---------------------------------------------------------------------------- # • Chave dos números. (Símbolos) #---------------------------------------------------------------------------- KEY_NUMBER = %W(NUMPAD0 NUMPAD1 NUMPAD2 NUMPAD3 NUMPAD4 NUMPAD5 NUMPAD6 NUMPAD7 NUMPAD8 NUMPAD9 N0 N1 N2 N3 N4 N5 N6 N7 N8 N9 MULTIPLY OEM_PERIOD OEM_COMMA ADD SEPARATOR DIVIDE SUBTRACT DECIMAL).collect!(&:intern) SPECIAL_CHAR_NUMBER = { N1: %w(! ¹), N2: %w(@ ²), N3: %w(# ³), N4: %w($ £), N5: %w(% ¢), N6: %w(¨ ¬), N7: %w(&), N8: %w(*), N9: ["("], N0: [")"], OEM_PERIOD: %w(>), OEM_COMMA: %w(<) } #---------------------------------------------------------------------------- # • Chave das letras. (Símbolos) #---------------------------------------------------------------------------- KEY_CHAR = %W(A B C D E F G H I J L K M N O P Q R S T U V W X Y Z Ç).collect!(&:intern) KEY_CHAR_ACCUTE = %W(A E I O U Y).collect!(&:intern) KEY_CHAR_ACCUTE_STR = { UPCASE: { A: %w(Â Ã À Á), E: %w(Ê ~E È É), I: %w(Î ~I Ì Í), O: %w(Ô Õ Ò Ó), Y: %w(^Y ~Y `Y Ý), U: %w(Û ~U Ù Ú) }, DOWNCASE: { A: %w(â ã à á), E: %w(ê ~e è é), I: %w(î ~i ì í), O: %w(ô õ ò ó), Y: %w(^y ~y `y ý), U: %w(û ~u ù ú) } } #---------------------------------------------------------------------------- # • Chaves especiais. #---------------------------------------------------------------------------- KEY_SPECIAL = %w(SPACE OEM_1 OEM_PLUS OEM_MINUS OEM_2 OEM_6 OEM_7 OEM_102).collect!(&:intern) SKEY_SPECIAL = { OEM_1: %w(? °), OEM_2: %w(:), OEM_7: %w(} º), OEM_6: %w({ ª), OEM_PLUS: %w(+ §), OEM_MINUS: %w(_), OEM_102: %w(|) } #---------------------------------------------------------------------------- # • Chaves especiais. [^~ ´` '"] #---------------------------------------------------------------------------- KEY_SPECIAL2 = %w(ACCUTE TIL QUOTE N6).collect!(&:intern) #---------------------------------------------------------------------------- # • Variáveis do módulo. #---------------------------------------------------------------------------- @_cacheText = "" @til = 0 @tils = false @accute = 0 @accutes = false @unpack_string = 'b'*256 @last_array = '0'*256 @press = Array.new(256, false) @trigger = Array.new(256, false) @repeat = Array.new(256, false) @release = Array.new(256, false) @repeat_counter = Array.new(256, 0) @getKeyboardState = API::GetKeyboardState @getAsyncKeyState = API::GetAsyncKeyState @getKeyboardState.call(@last_array) @last_array = @last_array.unpack(@unpack_string) for i in 0...@last_array.size @press[i] = @getAsyncKeyState.call(i) == 0 ? false : true end #---------------------------------------------------------------------------- # • Atualização. #---------------------------------------------------------------------------- def update @trigger = Array.new(256, false) @repeat = Array.new(256, false) @release = Array.new(256, false) array = '0'*256 @getKeyboardState.call(array) array = array.unpack(@unpack_string) for i in 0...array.size if array[i] != @last_array[i] @press[i] = @getAsyncKeyState.call(i) == 0 ? false : true if @repeat_counter[i] <= 0 && @press[i] @repeat[i] = true @repeat_counter[i] = 15 end if !@press[i] @release[i] = true else @trigger[i] = true end else if @press[i] == true @press[i] = @getAsyncKeyState.call(i) == 0 ? false : true @release[i] = true if !@press[i] end if @repeat_counter[i] > 0 && @press[i] == true @repeat_counter[i] -= 1 elsif @repeat_counter[i] <= 0 && @press[i] == true @repeat[i] = true @repeat_counter[i] = 3 elsif @repeat_counter[i] != 0 @repeat_counter[i] = 0 end end end @last_array = array end #-------------------------------------------------------------------------- # * [TrueClass/FalseClass] Obter o estado quando a chave for pressionada. # key : key index #-------------------------------------------------------------------------- def press?(key) return @press[ key.is_a?(Symbol) ? KEY.get(key) : key ] end #-------------------------------------------------------------------------- # * [TrueClass/FalseClass] Obter o estado quando a chave for teclada. # key : key index #-------------------------------------------------------------------------- def trigger?(key) return @trigger[ key.is_a?(Symbol) ? KEY.get(key) : key ] end #-------------------------------------------------------------------------- # * [TrueClass/FalseClass] Obter o estado quando a chave for teclada repetidamente. # key : key index #-------------------------------------------------------------------------- def repeat?(key) return @repeat[ key.is_a?(Symbol) ? KEY.get(key) : key ] end #-------------------------------------------------------------------------- # * [TrueClass/FalseClass] Obter o estado quando a chave for "lançada" # key : key index #-------------------------------------------------------------------------- def release?(key) return @release[ key.is_a?(Symbol) ? KEY.get(key) : key ] end #---------------------------------------------------------------------------- # • [String] Obtêm a string correspondente à tecla do número. Às Strings ficará # armazenada na varíavel _cacheText #---------------------------------------------------------------------------- def get_number(special=false) KEY_NUMBER.each { |key| unless special next @_cacheText.concat(API::MapVirtualKey.call(KEY.get(key), 2)) if trigger?(key) else if shift? next @_cacheText += SPECIAL_CHAR_NUMBER[key][0] || "" if trigger?(key) elsif ctrl_alt? next @_cacheText += SPECIAL_CHAR_NUMBER[key][1] || "" if trigger?(key) else next @_cacheText.concat(API::MapVirtualKey.call(KEY.get(key), 2)) if trigger?(key) end end } end #---------------------------------------------------------------------------- # • [String] Obtêm a string correspondente à tecla do teclado pressionado. # Às Strings ficará armazenada na varíavel _cacheText #---------------------------------------------------------------------------- def get_string(backslash=:trigger) get_number(true) KEY_CHAR.each { |key| next unless trigger?(key) x = "".concat(API::MapVirtualKey.call(KEY.get(key), 2)) if @tils n = shift? ? 0 : 1 if @tils x = KEY_CHAR_ACCUTE_STR[caps? ? :UPCASE : :DOWNCASE][key][n] || "" if KEY_CHAR_ACCUTE.include?(key) and !n.nil? @tils = false @accutes = false elsif @accutes n = shift? ? 2 : 3 if @accutes x = KEY_CHAR_ACCUTE_STR[caps? ? :UPCASE : :DOWNCASE][key][n] || "" if KEY_CHAR_ACCUTE.include?(key) and !n.nil? @tils = false @accutes = false end @_cacheText += (caps? ? x : x.downcase) } KEY_SPECIAL.each { |key| if shift? next @_cacheText += SKEY_SPECIAL[key][0] || "" if trigger?(key) elsif ctrl_alt? next @_cacheText += SKEY_SPECIAL[key][1] || "" if trigger?(key) else next @_cacheText.concat(API::MapVirtualKey.call(KEY.get(key), 2)) if trigger?(key) end } KEY_SPECIAL2.each { |key| if trigger?(key) if key == :TIL @tils = !@tils @accutes = false if @tils elsif key == :ACCUTE @accutes = !@accutes @tils = false if @accutes end @til = @til == 3 ? @til : @til + 1 if key == :TIL @accute = @accute == 3 ? @accute : @accute + 1 if key == :ACCUTE if shift? next @_cacheText += '"' if key == :QUOTE next unless @til == 3 or @accute == 3 @_cacheText += "^" if key == :TIL @_cacheText += "`" if key == :ACCUTE next @til = 0 if key == :TIL next @accute = 0 if key == :ACCUTE else next @_cacheText.concat(API::MapVirtualKey.call(KEY.get(key), 2)) if key == :QUOTE next unless @til == 3 or @accute == 3 @_cacheText += "~" if key == :TIL @_cacheText += "´" if key == :ACCUTE next @til = 0 if key == :TIL next @accute = 0 if key == :ACCUTE end end } if backslash == :press @_cacheText = @_cacheText.backslash if press?(:BACKSPACE) else @_cacheText = @_cacheText.backslash if trigger?(:BACKSPACE) end @_cacheText += " " * 4 if trigger?(:TAB) end #---------------------------------------------------------------------------- # • Verificar se o CAPS LOCK está ativado ou desativado. #---------------------------------------------------------------------------- def caps? API.get_caps_lock end #---------------------------------------------------------------------------- # • Verificar se o Shift está pressionado #---------------------------------------------------------------------------- def shift? press?(:SHIFT) end #---------------------------------------------------------------------------- # • Verificar se o CTRL + ALT está pressionado. #---------------------------------------------------------------------------- def ctrl_alt? (press?(:LCONTROL) and press?(:LALT)) or press?(:RALT) end #---------------------------------------------------------------------------- # • [Boolean] : Retorna true caso alguma tecla foi teclada. #---------------------------------------------------------------------------- def any? Key::KEY.each_value { |i| next if i == 25 return true if trigger?(i) } return false end #---------------------------------------------------------------------------- # • Para movimento WSAD #---------------------------------------------------------------------------- def wsad return 8 if press?(:W) return 4 if press?(:A) return 6 if press?(:D) return 2 if press?(:S) return 0 end end } #============================================================================== # • Sprite #============================================================================== Dax.register(:sprite, "dax", 3.0) { class Sprite #---------------------------------------------------------------------------- # • Variáveis públicas da instância. #---------------------------------------------------------------------------- attr_accessor :clone_sprite attr_accessor :outline_fill_rect #---------------------------------------------------------------------------- # • Novo método. Modos de usos abaixo: # * [normal] : É o método normal, na qual você não define nada. Sprite.new # * [viewport] : É o método na qual você define um viewport. # Sprite.new(Viewport) # * [system] : É o método na qual você já define um bitmap que irá carregar # uma imagem já direto da pasta System, através do Cache. # Sprite.new("S: Nome do Arquivo") # * [picture] : É o método na qual você já define um bitmap que irá carregar # uma imagem já direito da pasta Pictures, através do Cache. # Sprite.new("P: Nome do Arquivo") # * [graphics] : É o método na qual você já define um bitmap com uma imagem # que está dentro da pasta Graphics, através do Cache. # Sprite.new("G: Nome do Arquivo.") # * [width, height] : É o método na qual você já define a largura e altura # do bitmap. Sprite.new([width, height]) # * [elements] : É o método na qual você já define a largura, altura, # posição X, posição Y e Prioridade do bitmap. # Sprite.new([width, height, x, y, z]) #---------------------------------------------------------------------------- alias new_initialize initialize def initialize(viewport=nil) @clone_sprite = [] @outline_fill_rect = nil if viewport.is_a?(String) new_initialize(nil) if viewport.match(/S: ([^>]*)/) self.bitmap = Cache.system($1.to_s) elsif viewport.match(/P: ([^>]*)/) self.bitmap = Cache.picture($1.to_s) elsif viewport.match(/G: ([^>]*)/) self.bitmap = Cache.load_bitmap("Graphics/", $1.to_s) else self.bitmap = Bitmap.new(viewport) end elsif viewport.is_a?(Array) if viewport.size == 2 new_initialize(nil) self.bitmap = Bitmap.new(viewport[0], viewport[1]) elsif viewport.size == 5 new_initialize(nil) self.bitmap = Bitmap.new(viewport[0], viewport[1]) self.x, self.y, self.z = viewport[2], viewport[3], viewport[4] end elsif viewport.is_a?(Viewport) or viewport.nil? new_initialize(viewport) end end #---------------------------------------------------------------------------- # • Renovação do Sprite. #---------------------------------------------------------------------------- alias :dax_core_dispose :dispose def dispose dax_core_dispose @outline_fill_rect.dispose unless @outline_fill_rect.nil? or @outline_fill_rect.disposed? end #---------------------------------------------------------------------------- # • Definir um contorno no Sprite em forma de retângulo. # color : Cor do contorno. # size : Tamanho da linha do contorno. # vis : Visibilidade. true - visível | false - invisível. #---------------------------------------------------------------------------- def set_outline(color=Color.new.default, size=2, vis=true) @outline_fill_rect = Sprite.new([self.width, self.height, self.x, self.y, self.z+2]) @outline_fill_rect.bitmap.fill_rect(0, 0, self.width, size, color) @outline_fill_rect.bitmap.fill_rect(0, self.height-size, self.width, size, color) @outline_fill_rect.bitmap.fill_rect(0, 0, size, self.height, color) @outline_fill_rect.bitmap.fill_rect(self.width-size, 0, size, self.height, color) @outline_fill_rect.visible = vis end #---------------------------------------------------------------------------- # • Atualização do contorno. # vis : Visibilidade. true - visível | false - invisível. #---------------------------------------------------------------------------- def update_outline(vis=true) @outline_fill_rect.visible = vis @outline_fill_rect.x, @outline_fill_rect.y = self.x, self.y end #---------------------------------------------------------------------------- # • Slide pela direita. # * speed : Velocidade | point : Ponto da coordenada X que irá chegar. #---------------------------------------------------------------------------- def slide_right(speed, point) self.x += speed unless self.x >= point end #---------------------------------------------------------------------------- # • Slide pela esquerda. # * speed : Velocidade | point : Ponto da coordenada X que irá chegar. #---------------------------------------------------------------------------- def slide_left(speed, point) self.x -= speed unless self.x <= point end #---------------------------------------------------------------------------- # • Slide por cima. # * speed : Velocidade | point : Ponto da coordenada Y que irá chegar. #---------------------------------------------------------------------------- def slide_up(speed, point) self.y -= speed unless self.y <= point end #---------------------------------------------------------------------------- # • Slide por baixo. # * speed : Velocidade | point : Ponto da coordenada Y que irá chegar. #---------------------------------------------------------------------------- def slide_down(speed, point) self.y += speed unless self.y >= point end #---------------------------------------------------------------------------- # • Define aqui uma posição fixa para um objeto. # command : Veja na classe Position. #---------------------------------------------------------------------------- def position(command=0) return if command.nil? Position[command, self] end #---------------------------------------------------------------------------- # • [Numeric] : Tamanho geral #---------------------------------------------------------------------------- def size return self.width + self.height end #---------------------------------------------------------------------------- # • [Rect] : Retorna ao Rect do Bitmap. #---------------------------------------------------------------------------- def rect return self.bitmap.rect end #---------------------------------------------------------------------------- # • Base para clonar um Sprite. # * depht : Prioridade no mapa. # * clone_bitmap : Se irá clonar o bitmap. # Exemplo: sprite = sprite2.clone #---------------------------------------------------------------------------- def clone(depht=0, clone_bitmap=false) @clone_sprite.delete_if { |bitmap| bitmap.disposed? } cloned = Sprite.new(self.viewport) cloned.x, cloned.y = self.x, self.y cloned.bitmap = self.bitmap cloned.bitmap = self.bitmap.clone if clone_bitmap unless depht == 0 cloned.z = self.z + depht else @clone_sprite.each { |sprite| sprite.z -= 1 } cloned.z = self.z - 1 end cloned.src_rect.set(self.src_rect) ["zoom_x", "zoom_y", "angle", "mirror", "opacity", "blend_type", "visible", "ox", "oy"].each { |meth| eval("cloned.#{meth} = self.#{meth}") } cloned.color.set(color) cloned.tone.set(tone) after_clone(cloned) @clone_sprite.push(cloned) return cloned end #---------------------------------------------------------------------------- # • Efeito após ter clonado o Sprite. #---------------------------------------------------------------------------- def after_clone(clone) end #---------------------------------------------------------------------------- # • O que irá acontecer sê o mouse estiver em cima do sprite? #---------------------------------------------------------------------------- def mouse_over end #---------------------------------------------------------------------------- # • O que irá acontecer sê o mouse não estiver em cima do sprite? #---------------------------------------------------------------------------- def mouse_no_over end #---------------------------------------------------------------------------- # • O que irá acontecer sê o mouse clicar no objeto #---------------------------------------------------------------------------- def mouse_click end #---------------------------------------------------------------------------- # • Atualização dos sprites. #---------------------------------------------------------------------------- alias :dax_update :update def update(*args, &block) dax_update(*args, &block) unless Mouse.cursor.nil? self.if_mouse_over { |over| over ? mouse_over : mouse_no_over } self.if_mouse_click { mouse_click } end end #---------------------------------------------------------------------------- # • Inverter o lado do sprite. #---------------------------------------------------------------------------- def mirror! self.mirror = !self.mirror end #---------------------------------------------------------------------------- # • Inverter o ângulo do sprite em 180°(Pode ser mudado.). #---------------------------------------------------------------------------- def angle!(ang=180) self.ox, self.oy = self.bitmap.width, self.bitmap.height self.angle += ang self.angle += 360 while self.angle < 0 self.angle %= 360 end end } #============================================================================== # • Bitmap #============================================================================== Dax.register(:bitmap, "dax", 3.0) { class Bitmap #-------------------------------------------------------------------------- # • Constantes. #-------------------------------------------------------------------------- Directory = 'Data/Bitmaps/' #-------------------------------------------------------------------------- # • Salvar as informações do bitmap em um arquivo. #-------------------------------------------------------------------------- def self.saveInfo(bitmap, filename) return unless bitmap.is_a?(Bitmap) red = Table.new(bitmap.width, bitmap.height) green = Table.new(bitmap.width, bitmap.height) blue = Table.new(bitmap.width, bitmap.height) alpha = Table.new(bitmap.width, bitmap.height) bitmap.rect.step(1, 1) { |i, j| color = bitmap.get_pixel(i, j) red[i, j] = color.red green[i, j] = color.green blue[i, j] = color.blue alpha[i, j] = color.alpha } Dir.mkdir(Directory) unless File.directory?(Directory) file = File.open(Directory + filename + '.rvdata2', 'wb') Marshal.dump([red, green, blue, alpha], file) file.close puts "bitmap saved" end #-------------------------------------------------------------------------- # * Abrir o arquivo. #-------------------------------------------------------------------------- def self.readInfo(filename) return unless FileTest.exist?(Directory + filename + '.rvdata2') file = File.open(Directory + filename + '.rvdata2', "rb") colors = Marshal.load(file).compact file.close red, green, blue, alpha = *colors bitmap = Bitmap.new(red.xsize, red.ysize) for i in 0...bitmap.width for j in 0...bitmap.height bitmap.set_pixel(i, j, Color.new(red[i, j], green[i, j], blue[i, j], alpha[i, j])) end end return bitmap end #---------------------------------------------------------------------------- # • Modifica o sprite para ficar do tamanho definido. #---------------------------------------------------------------------------- def resize(width=Graphics.width, height=Graphics.height) self.stretch_blt(Rect.new(0, 0, width, height), self, self.rect) end #---------------------------------------------------------------------------- # • Criar uma barra. # color : Objeto de Cor [Color] # actual : Valor atual da barra. # max : Valor máximo da barra. # borda : Tamanho da borda da barra. #---------------------------------------------------------------------------- def bar(color, actual, max, borda=1) rate = self.width.to_p(actual, max) self.fill_rect(borda, borda, rate-(borda*2), self.height-(borda*2), color) end #---------------------------------------------------------------------------- # • Barra em forma de gradient. # color : Objeto de Cor, em forma de [Array] para conter 2 [Color] # exemplo -> [Color.new(x), Color.new(y)] # actual : Valor atual da barra. # max : Valor máximo da barra. # borda : Tamanho da borda da barra. #---------------------------------------------------------------------------- def gradient_bar(color, actual, max, borda=1) rate = self.width.to_p(actual, max) self.gradient_fill_rect(borda, borda, rate-(borda*2), self.height-(borda*2), color[0], color[1], 2) end #---------------------------------------------------------------------------- # • Limpar uma área num formato de um círculo. #---------------------------------------------------------------------------- def clear_rect_circle(x, y, r) rr = r*r for i in 0...r adj = Math.sqrt(rr - (i*i)).ceil xd = x - adj wd = 2 * adj self.clear_rect(xd, y-i, wd, 1) self.clear_rect(xd, y+i, wd, 1) end end #---------------------------------------------------------------------------- # • Novo modo de desenhar textos. Configurações já especificadas. #---------------------------------------------------------------------------- def draw_text_rect(*args) self.draw_text(self.rect, *args) end #---------------------------------------------------------------------------- # • Permite salvar várias imagens em cima de outra. # Exemplo de comando: # Bitmap.overSave("Pictures/Nova", "Pictures/1", "Characters/2", # "Pictures/3", "Characters/4", "Pictures/5") # NÃO ESQUEÇA DE ESPECIFICAR ÀS PASTAS. #---------------------------------------------------------------------------- def self.overSave(newfile, first, *args) return if first.empty? || first.nil? || args.empty? || args.nil? firstB = Bitmap.new("Graphics/"+first) args.each { |outhers| firstB.stretch_blt(firstB.rect, Bitmap.new("Graphics/"+outhers), firstB.rect) } firstB.save("Graphics/"+newfile) end #---------------------------------------------------------------------------- # • Modificar as cores do [Bitmap] para ficarem Negativas. #---------------------------------------------------------------------------- def negative self.rect.step(1.0, 1.0) { |i, j| pix = self.get_pixel(i, j) pix.red = (pix.red - 255) * -1 pix.blue = (pix.blue - 255) * -1 pix.green = (pix.green - 255) * -1 self.set_pixel(i, j, pix) } end #---------------------------------------------------------------------------- # • Grayscale : Modificar as cores do [Bitmap] para cor cinza. Efeito cinza. #---------------------------------------------------------------------------- def grayscale(rect = Rect.new(0, 0, self.width, self.height)) self.rect.step(1, 1) { |i, j| colour = self.get_pixel(i,j) grey_pixel = (colour.red*0.3 + colour.green*0.59 + colour.blue*0.11) colour.red = colour.green = colour.blue = grey_pixel self.set_pixel(i,j,colour) } end #---------------------------------------------------------------------------- # • Converter as cores para sepia. #---------------------------------------------------------------------------- def sepia2 self.rect.step(1, 1) { |w, h| nrow = row = get_pixel(w, h) row.red = [(0.393 * nrow.red) + (0.769 * nrow.green) + (0.189 * nrow.blue), 255].min row.green = [(0.349 * nrow.red) + (0.689 * nrow.green) + (0.168 * nrow.blue), 255].min row.blue = [(0.272 * nrow.red) + (0.534 * nrow.green) + (0.131 * nrow.blue), 255].min set_pixel(w, h, row) } end #---------------------------------------------------------------------------- # • Suavidade nas cores do bitmap. Converte as cores em preto e branco. # crlz : Controle da iluminidade. #---------------------------------------------------------------------------- def black_whiteness(ctlz=2.0) self.rect.step(1, 1) { |w, h| row = get_pixel(w, h) getArray__row = row.to_a(false) lightCalc_ = (getArray__row.max + getArray__row.min) / ctlz row.red = row.green = row.blue = lightCalc_ set_pixel(w, h, row) } end #---------------------------------------------------------------------------- # • Novo fornecedor de pixel. #---------------------------------------------------------------------------- def set_pixel_s(x, y, color, size) for i in 0...size self.set_pixel(x+i, y, color) self.set_pixel(x-i, y, color) self.set_pixel(x, y+i, color) self.set_pixel(x, y-i, color) self.set_pixel(x+i, y+i, color) self.set_pixel(x-i, y-i, color) self.set_pixel(x+i, y-i, color) self.set_pixel(x-i, y+i, color) end end #---------------------------------------------------------------------------- # • Desenhar uma linha. # start_x : Início da linha em X. # start_y : Início da linha em Y. # end_x : Finalização da linha em X. # end_y : Finalização da linha em Y. #---------------------------------------------------------------------------- def draw_line(start_x, start_y, end_x, end_y, color, size=1) set_pixel_s(start_x, start_y, color, size) distance = (start_x - end_x).abs + (start_y - end_y).abs for i in 1..distance x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i set_pixel_s(x, y, color, size) end set_pixel_s(end_x, end_y, color, size) end #---------------------------------------------------------------------------- # • draw_bar_gauge(x, y, current, current_max, border, colors) # x : Coordenadas X. # y : Coordenadas Y. # current : Valor atual da barra. # current_max : Valor maxímo da barra. # border : Expressura da borda. # colors : Cores. [0, 1] #---------------------------------------------------------------------------- # Permite adicionar uma barra. #---------------------------------------------------------------------------- def draw_bar_gauge(x, y, current, current_max, colors=[]) cw = self.width.to_p(current, current_max) ch = self.height self.gradient_fill_rect(x, y, self.width, self.height, colors[0], colors[1]) src_rect = Rect.new(0, 0, cw, ch) self.blt(x, y, self, src_rect) end #---------------------------------------------------------------------------- # • draw_icon(icon_index, x, y, enabled) # icon_index : ID do ícone. # x : Coordenadas X. # y : Coordenadas Y. # enabled : Habilitar flag, translucido quando false # filename : Podes definir uma imagem: Basta # por o nome da imagem, ela deve estar na pasta System. #---------------------------------------------------------------------------- def draw_icon(icon_index, x, y, enabled = true, filename="IconSet") icon_index = icon_index.nil? ? 0 : icon_index bitmap = Cache.system(filename) rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24) self.blt(x, y, bitmap, rect, enabled ? 255 : 128) end #---------------------------------------------------------------------------- # • draw_gradation_gauge(x, y, width, height, current, current_max, border, colors, align) # x : Coordenadas X. # y : Coordenadas Y. # width : Largura da barra. # height : Altura da barra. # current : Valor atual da barra. # current_max : Valor maxímo da barra. # border : Expressura da borda. # colors : Cores. [0, 1] # align : Alinhamento. #---------------------------------------------------------------------------- # Permite adicionar uma barra. #---------------------------------------------------------------------------- def draw_gradation_gauge(x, y, current, current_max, border, colors=[]) cw = self.width.to_p(current, current_max) ch = self.height self.fill_rect(x, y, self.width, self.height, colors[0]) self.gradient_fill_rect(x+border, y+border, self.width-(border/2), self.height-(border/2), colors[1], colors[2]) src_rect = Rect.new(0, 0, cw, ch) self.blt(x, y, self, src_rect) end #---------------------------------------------------------------------------- # • Desenhar um círuclo preenchido. #---------------------------------------------------------------------------- def fill_circle(x, y, r, c) rr = r*r for i in 0...r adj = Math.sqrt(rr - (i*i)).ceil xd = x - adj wd = 2 * adj self.fill_rect(xd, y-i, wd, 1, c) self.fill_rect(xd, y+i, wd, 1, c) end end #---------------------------------------------------------------------------- # • [Brilho] : Aumentar/Diminuir o brilho do sprite. #---------------------------------------------------------------------------- def brightness(vl = 100) self.rect.step(1.0, 1.0) { |i, j| pix = self.get_pixel(i, j) pix = pix.percent(vl) self.set_pixel(i, j, pix) } end end } #============================================================================== # • Mouse #============================================================================== Dax.register(:mouse, "dax", 2.5) { module Mouse extend self #-------------------------------------------------------------------------- # • Inicialização dos objetos. #-------------------------------------------------------------------------- def start @cursor = Sprite_Mouse.new(Dax::MOUSE_NAME, -128, -128, 100000) @graphic = Dax::MOUSE_NAME x = Dax::MOUSE_NAME == "" ? 1 : 0 API::MouseShowCursor.call(x) @visible = true end #---------------------------------------------------------------------------- # • visible = (boolean) # * boolean : true ou false # Tornar vísivel ou não o cursor do Mouse. #---------------------------------------------------------------------------- def visible=(boolean) @visible = boolean end #-------------------------------------------------------------------------- # • graphic(graphic_set) # graphic_set : Se for número é um ícone; Se for string é uma imagem. #-------------------------------------------------------------------------- def graphic(graphic_set) visible = false @graphic = graphic_set @cursor.set_graphic = graphic_set end #-------------------------------------------------------------------------- # • show(visible) # visible : True - para mostrar o mouse | False - para esconder o mouse. #-------------------------------------------------------------------------- def show(vis=true) @cursor.visible = vis end #-------------------------------------------------------------------------- # • update (Atualização das coordenadas) #-------------------------------------------------------------------------- def update return if @cursor.nil? API::MouseShowCursor.call(@visible.boolean) if @cursor.disposed? @cursor = Sprite_Mouse.new(@graphic, 0, 0, 100000) end @cursor.update @cursor.x, @cursor.y = position end #-------------------------------------------------------------------------- # • Retorna a variável '@cursor' que tem como valor a classe [Sprite]. #-------------------------------------------------------------------------- def cursor @cursor end #-------------------------------------------------------------------------- # • Clear. #-------------------------------------------------------------------------- def clear @cursor.dispose end #-------------------------------------------------------------------------- # • x (Coordenada X do Mouse) #-------------------------------------------------------------------------- def x @cursor.x rescue 0 end #-------------------------------------------------------------------------- # • y (Coordenada Y do Mouse) #-------------------------------------------------------------------------- def y @cursor.y rescue 0 end #-------------------------------------------------------------------------- # • position (Posição do Mouse!) #-------------------------------------------------------------------------- def position x, y = get_client_position return x, y end #-------------------------------------------------------------------------- # • Grid do mapa. #-------------------------------------------------------------------------- def map_grid return unless defined?($game_map) return nil if x == nil or y == nil rx = ($game_map.display_x).to_i + (x / 32) ry = ($game_map.display_y).to_i + (y / 32) return [rx.to_i, ry.to_i] end #-------------------------------------------------------------------------- # • get_client_position (Posição original do Mouse!) #-------------------------------------------------------------------------- def get_client_position pos = [0, 0].pack('ll') API::CursorPosition.call(pos) API::ScreenToClient.call(WINDOW, pos) return pos.unpack('ll') end #-------------------------------------------------------------------------- # • Verificação se o mouse está na área de um determinado objeto. #-------------------------------------------------------------------------- def in_area?(x) return if @cursor.disposed? return unless x.is_a?(Sprite) or x.is_a?(Window) #return @cursor.x.between?(object_sprite.x, object_sprite.x + object_sprite.width) && # @cursor.y.between?(object_sprite.y, object_sprite.y + object_sprite.height) @cursor.x.between?(x.x, (x.x - x.ox + (x.viewport ? x.viewport.rect.x : 0)) + x.width) && @cursor.y.between?(x.y, (x.y - x.oy + (x.viewport ? x.viewport.rect.y : 0)) + x.height) end #---------------------------------------------------------------------------- # • Verificar se o mouse está em determinada área #---------------------------------------------------------------------------- def area?(x, y, width, height) return if @cursor.disposed? return @cursor.x.between?(x, x + width) && @cursor.y.between?(y, y + height) end #---------------------------------------------------------------------------- # • Mudar posição do cursor. #---------------------------------------------------------------------------- def set_pos(pos) pos = pos.position unless pos.is_a? Position API::SetCursorPos.call(pos.x, pos.y) update @cursor.x = pos.x @cursor.y = pos.y end #---------------------------------------------------------------------------- # • Verifica se clicou com o botão esquerdo do Mouse. #---------------------------------------------------------------------------- def left? return Key.trigger?(0x01) end #---------------------------------------------------------------------------- # • Verifica se clicou com o botão direito do Mouse. #---------------------------------------------------------------------------- def right? return Key.trigger?(0x02) end WINDOW = API.hWND end #============================================================================== # • Sprite_Mouse #============================================================================== class Sprite_Mouse < Sprite #---------------------------------------------------------------------------- # • Variáveis públicas da instância. #---------------------------------------------------------------------------- attr_accessor :set_graphic # definir o gráfico. #---------------------------------------------------------------------------- # • Inicialização dos objetos. #---------------------------------------------------------------------------- def initialize(graphic, x, y, z) super(nil) @set_graphic = graphic if @set_graphic.is_a?(Fixnum) self.bitmap = Bitmap.new(24, 24) self.bitmap.draw_icon(@set_graphic, 0, 0) elsif @set_graphic.is_a?(NilClass) or @set_graphic == "" self.bitmap = Bitmap.new(1, 1) elsif @set_graphic.is_a?(String) self.bitmap = Cache.system(@set_graphic) end self.x, self.y, self.z = x, y, z @older = @set_graphic end #---------------------------------------------------------------------------- # • Renovação dos objetos. #---------------------------------------------------------------------------- def dispose self.bitmap.dispose super end #---------------------------------------------------------------------------- # • Atualização dos objetos. #---------------------------------------------------------------------------- def update super unless @older == @set_graphic if @set_graphic.is_a?(Fixnum) self.bitmap = Bitmap.new(24, 24) self.bitmap.draw_icon(@set_graphic, 0, 0) elsif @set_graphic.is_a?(NilClass) or @set_graphic == "" self.bitmap = Bitmap.new(1, 1) elsif @set_graphic.is_a?(String) self.bitmap = Cache.system(@set_graphic) end @older = @set_graphic end end end Mouse.start } #============================================================================== # • Powershell #============================================================================== Dax.register(:powershell, "dax", 2.0) { module Powershell extend self #---------------------------------------------------------------------------- # • Command #---------------------------------------------------------------------------- def run(cmd) system("powershell.exe " << cmd) end #---------------------------------------------------------------------------- # • Baixar arquivos da internet com a função wget # link : url # output : filename and dest # ext : commands # -v : show progress. # -c : continuar; # -b : in background #---------------------------------------------------------------------------- def wget(link, output, ext="-v") cmd = "wget #{ext} #{link} -OutFile #{output}" self.run(cmd) end #downloadCommandHere def downloadProgress(filename, url) #run(%Q( -executionpolicy bypass "& ""#{Dir.pwd}/_dCodeProgress.ps1""")) end end } #============================================================================== # • Object #============================================================================== Dax.register(:object, "dax", 2.0) { class Object #---------------------------------------------------------------------------- # • powershell exec command # cmd : Command #---------------------------------------------------------------------------- def powershell(cmd) Powershell.run(cmd) end alias :ps :powershell #---------------------------------------------------------------------------- # • [Hex] : Retorna ao id do objeto em hexadécimal. #---------------------------------------------------------------------------- def __hexid__ "0x" + ('%.X' % (self.__id__ * 2)) end #---------------------------------------------------------------------------- # • O que irá ocorrer caso o mouse esteja sobre uma sprite. # Tem que ser um objeto Sprite. #---------------------------------------------------------------------------- def if_mouse_over(&block) return if Mouse.cursor.nil? return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given? over ||= false if Mouse.in_area?(self) block.call over = true else over = false end yield over end #---------------------------------------------------------------------------- # • O que irá ocorrer caso o mouse esteja sobre uma sprite, e ao clicar. # Tem que ser um objeto Sprite. # * button : Button : (:right - botão direito do mouse | :left - botão esq.) # EXPLICAÇÕES NO FINAL DO SCRIPT. #---------------------------------------------------------------------------- def if_mouse_click(button=:left, &block) return if Mouse.cursor.nil? return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given? button = button == :left ? 0x01 : button == :right ? 0x02 : 0x01 block.call if Mouse.in_area?(self) and trigger?(button) end #---------------------------------------------------------------------------- # • O que irá ocorrer caso o mouse esteja sobre uma sprite, e ao pressionar. # Tem que ser um objeto Sprite. # * button : Button : (:right - botão direito do mouse | :left - botão esq.) #---------------------------------------------------------------------------- def if_mouse_press(button=:left, &block) return if Mouse.cursor.nil? return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given? button = button == :left ? 0x01 : button == :right ? 0x02 : 0x01 block.call if Mouse.in_area?(self) and press?(button) end #---------------------------------------------------------------------------- # • O que irá ocorrer caso o mouse esteja sobre uma sprite, e ao ficar clicando. # Tem que ser um objeto Sprite. # * button : Button : (:right - botão direito do mouse | :left - botão esq.) #---------------------------------------------------------------------------- def if_mouse_repeat(button=:left, &block) return if Mouse.cursor.nil? return unless self.is_a?(Sprite) or self.is_a?(Window_Base) or block_given? button = button == :left ? 0x01 : button == :right ? 0x02 : 0x01 block.call if Mouse.in_area?(self) and repeat?(button) end #---------------------------------------------------------------------------- # • Trigger # * key : Chave. # Você também pode usá-lo como condição para executar tal bloco; #---------------------------------------------------------------------------- # trigger?(key) { bloco que irá executar } #---------------------------------------------------------------------------- def trigger?(key, &block) if key == :C or key == :B ckey = Input.trigger?(key) else ckey = Key.trigger?(key) end return ckey unless block_given? block.call if ckey end #---------------------------------------------------------------------------- # • Press # * key : Chave. # Você também pode usá-lo como condição para executar tal bloco; #---------------------------------------------------------------------------- # press?(key) { bloco que irá executar. } #---------------------------------------------------------------------------- def press?(key, &block) if key == :C or key == :B ckey = Input.press?(key) else ckey = Key.press?(key) end return ckey unless block_given? block.call if ckey end #---------------------------------------------------------------------------- # • Repeat # * key : Chave. # Você também pode usá-lo como condição para executar tal bloco; #---------------------------------------------------------------------------- # repeat?(key) { bloco que irá executar. } #---------------------------------------------------------------------------- def repeat?(key, &block) if key == :C or key == :B ckey = Input.repeat?(key) else ckey = Key.repeat?(key) end return ckey unless block_given? block.call if ckey end #---------------------------------------------------------------------------- # • Retorna em forma de número os valores true ou false. E caso seja # 0 ou 1.. retorna a true ou false. # Se for true, retorna a 1. # Se for false, retorna a 0. # Se for 1, retorna a true. # Se for 0, retorna a false. #---------------------------------------------------------------------------- def boolean return self.is_a?(Integer) ? self == 0 ? false : 1 : self ? 1 : 0 end #---------------------------------------------------------------------------- # • Converte para a classe Position. #---------------------------------------------------------------------------- def position return Position.new(self, self) if self.is_a?(Numeric) return Position.new(self.x, self.y) if self.is_a?(Sprite) or self.is_a?(Window_Base) or self.is_a?(Rect) return Position.new(self[0], self[1]) if self.is_a?(Array) return Position.new(self[:x], self[:y]) if self.is_a?(Hash) return Position.new(self.x, self.y) if defined?(self.x) and defined?(self.y) return Position.new(0, 0) end #---------------------------------------------------------------------------- # • Transforma em cor. # Se for uma Array. Exemplo: [128, 174, 111].color =># Color.new(128, 174, 111) # Se for uma String. Exemplo: "ffffff".color =># Color.new(255,255,255) #---------------------------------------------------------------------------- def color return Color.new(*self) if self.is_a?(Array) return Color.new.hex(self) if self.is_a?(String) end end } #============================================================================== # • Entries #============================================================================== Dax.register(:entries, "dax", 2.0) { class Entries #---------------------------------------------------------------------------- # • [Array] : Irá retornar a todos os nomes dos arquivos da pasta, dentro de # uma Array em formato de String. #---------------------------------------------------------------------------- attr_accessor :file #---------------------------------------------------------------------------- # • [Integer] : Retorna a quantidade total de arquivos que têm na pasta. #---------------------------------------------------------------------------- attr_reader :size #---------------------------------------------------------------------------- # • Inicialização dos objetos. # directory : Nome da pasta. Não ponha '/' no final do nome. Ex: 'Data/' # typefile : Nome da extensão do arquivo. Não ponha '.' no começo. Ex: '.txt' #---------------------------------------------------------------------------- def initialize(directory, typefile) return unless FileTest.directory?(directory) @file = Dir.glob(directory + "/*.{" + typefile + "}") @file.each_index { |i| @size = i.to_i } @name = split @file[0] end #---------------------------------------------------------------------------- # • [String] : Separar o nome do arquivo do nome da pasta. #---------------------------------------------------------------------------- def split(file) file.to_s.split('/').last end #---------------------------------------------------------------------------- # • [String] : Obtêm o nome do arquivo correspondente ao id configurado, # separado do nome da pasta. #---------------------------------------------------------------------------- def name(id) return if @file.nil? return split(@file[id]) end end } #============================================================================== # • DRGSS | Comandos do RGSS... #============================================================================== Dax.register(:drgss, "dax", 1.0) { module DRGSS extend self #---------------------------------------------------------------------------- # • Extrair scripts do Database para um arquivo de extensão de texto. # options : Caso você deixe assim: {folder: "NM"} # NM => Nome da pasta na qual os arquivos irão. #---------------------------------------------------------------------------- def extract_scripts(type=".txt",options={}) except = options[:except] || [] folder = options[:folder] || "" id = 0 # $RGSS_SCRIPTS.each do |script| name = script[1] data = script[3] next if except.include? name or name.empty? or data.empty? filename = sprintf("%03d", id) + "_" + name puts "Writing: #{filename}" File.open(folder+filename+"#{type}", "wb") do |file| file.write data end id += 1 end end end } #============================================================================== # • Backup Complete #============================================================================== Dax.register(:backup, "dax", 3.0) { module Backup extend self #---------------------------------------------------------------------------- # • Const. #---------------------------------------------------------------------------- DIR = "./Backup" COPYFILE = ->(*args) { API::CopyFile.call(*args) } #---------------------------------------------------------------------------- # • Call. #---------------------------------------------------------------------------- def run(complete=false) return unless $TEST Dir.mkdir(DIR) unless FileTest.directory? DIR complete ? call_complete : call_data end private #---------------------------------------------------------------------------- # • Call of the Data. #---------------------------------------------------------------------------- def call_data Dir.mkdir(DIR + "/Data") unless FileTest.directory? DIR + "/Data" Dir.glob("./Data/*").each { |_data| COPYFILE[_data, DIR + _data, 1] } end #---------------------------------------------------------------------------- # • Call Complete. #---------------------------------------------------------------------------- def call_complete Dir.glob(File.join("**", "**")).each { |_backup| next if _backup.match(/Backup/im) _dir = FileTest.directory?(_backup) ? _backup : _backup.gsub!(/\/\.(\w+)/, "") Dir.mkdir(DIR + "/#{_dir}") unless FileTest.directory? DIR + "/#{_dir}" COPYFILE[_backup, DIR + "/" + _backup, 1] } end end } #============================================================================== # * SceneManager #============================================================================== Dax.register(:scenemanager, "dax", 1.0) { if defined?("SceneManager") class << SceneManager #-------------------------------------------------------------------------- # • Chama uma outra scene. # scene_symbol : Nome da scene, podendo ser em símbolo ou string. #-------------------------------------------------------------------------- def symbol(scene_symbol) eval("self.call(#{scene_symbol.to_s})") end alias :eval :symbol end end } #============================================================================== # • Sprite_Text #============================================================================== Dax.register(:sprite_text, "dax", 2.0) { class Sprite_Text < Sprite #---------------------------------------------------------------------------- # • Variáveis públicas da instância. #---------------------------------------------------------------------------- attr_accessor :text # Mudar de texto... attr_accessor :align #---------------------------------------------------------------------------- # • Inicialização dos objetos. #---------------------------------------------------------------------------- def initialize(x, y, width, height, text, align=0) super([width, height]) self.x, self.y = x, y @text = text @align = align self.bitmap.draw_text_rect(@text, align) end #---------------------------------------------------------------------------- # • Renovação dos objetos. #---------------------------------------------------------------------------- def dispose self.bitmap.dispose super end #---------------------------------------------------------------------------- # • Atualização dos objetos. #---------------------------------------------------------------------------- def update self.bitmap.clear unless self.bitmap.disposed? super self.bitmap.draw_text_rect(@text, @align) end def size=(value=18) self.bitmap.font.size = value end def name=(value=nil) self.bitmap.font.name = value || "Arial" end #---------------------------------------------------------------------------- # • Negrito na fonte? #---------------------------------------------------------------------------- def bold=(value=nil) self.bitmap.font.bold = value || true end #---------------------------------------------------------------------------- # • Itálico na fonte? #---------------------------------------------------------------------------- def italic=(value=nil) self.bitmap.font.italic = value || true end #---------------------------------------------------------------------------- # • Sombra na fonte? #---------------------------------------------------------------------------- def shadow=(value=nil) self.bitmap.font.shadow = value || true end #---------------------------------------------------------------------------- # • Borda na fonte? #---------------------------------------------------------------------------- def outline=(value=nil) self.bitmap.font.outline = value || true end #---------------------------------------------------------------------------- # • Mudar a cor da fonte: #---------------------------------------------------------------------------- def color=(color=nil) self.bitmap.font.color = color || Color.new.default end #---------------------------------------------------------------------------- # • Mudar a cor da borda da fonte. #---------------------------------------------------------------------------- def out_color=(out_color=nil) self.bitmap.font.out_color = out_color || Color.new.hex("000000") end end } #============================================================================== # • Opacity #============================================================================== Dax.register(:opacity, "dax", 2.0) { module Opacity extend self @key ||= {} @time ||= {} #---------------------------------------------------------------------------- # • Efeito de opacidade que vai aumentando e diminuindo. # sprite : Objeto na qual sofrerá o efeito. [Sprite] # speed : Velocidade na qual o efeito irá acontencer. # max : Valor máximo na qual irá ser atingido. # min : Valor minímo na qual irá ser atingido. #---------------------------------------------------------------------------- def sprite_opacity(sprite, speed, max, min, hash=nil) @key[hash.nil? ? hash.__id__ : hash] || false unless @key[hash] sprite.opacity += speed unless sprite.opacity >= max @key[hash] = sprite.opacity >= max else sprite.opacity -= speed unless sprite.opacity <= min @key[hash] = false if sprite.opacity <= min end end #---------------------------------------------------------------------------- # • Efeito de opacidade por fora. # sprite : Objeto na qual sofrerá o efeito. [Sprite] # speed : Velocidade na qual o efeito irá acontencer. # max : Valor máximo na qual irá ser atingido. #---------------------------------------------------------------------------- def sprite_opacity_out(sprite, speed, max) return if sprite.nil? sprite.opacity += speed unless sprite.opacity >= max end #---------------------------------------------------------------------------- # • Efeito de opacidade por dentro. # sprite : Objeto na qual sofrerá o efeito. [Sprite] # speed : Velocidade na qual o efeito irá acontencer. # min : Valor minímo na qual irá ser atingido. #---------------------------------------------------------------------------- def sprite_opacity_in(sprite, speed, min) sprite.opacity -= speed unless sprite.opacity <= min end #---------------------------------------------------------------------------- # • Limpar variável. #---------------------------------------------------------------------------- def clear @key.clear end end } #============================================================================== # • Read #============================================================================== Dax.register(:read, "dax", 1.0) { module Read extend self #---------------------------------------------------------------------------- # • Verificar valor numérico após uma palavra em um arquivo. #---------------------------------------------------------------------------- def numeric(file, tag) IO.readlines(file).each do |line| return $1.to_i if line.match(/#{tag}(\d+)/) end end #---------------------------------------------------------------------------- # • Verificar valor de uma palavra(string única) após uma palavra em um arquivo #---------------------------------------------------------------------------- def string(file, tag) IO.readlines(file).each do |line| return $1.to_s if line.match(/#{tag}(\w+)/) end end #---------------------------------------------------------------------------- # • Verificar um conteúdo após uma palavra de um arquivo. #---------------------------------------------------------------------------- def content(file, tag) IO.readlines(file).each do |line| return $1 if line.match(/#{tag}([^>]*)/) end end #---------------------------------------------------------------------------- # • Multiplo número.. #---------------------------------------------------------------------------- def multiple_numeric(file, tag) IO.readlines(file).each do |line| return [$1.to_i, $2.to_i] if line.match(/#{tag}(\d+), (\d+)/) end end #---------------------------------------------------------------------------- # • Multiplo string.. #---------------------------------------------------------------------------- def multiple_string(file, tag) IO.readlines(file).each do |line| return [$1.to_s, $2.to_s] if line.match(/#{tag}(\w+), (\w+)/) end end #---------------------------------------------------------------------------- # • Triplo número. #---------------------------------------------------------------------------- def triple_numeric(file, tag) IO.readlines(file).each do |line| return [$1.to_i, $2.to_i, $3.to_i] if line.match(/#{tag}(\d+), (\d+), (\d+)/) end end #---------------------------------------------------------------------------- # • Triplo string. #---------------------------------------------------------------------------- def triple_string(file, tag) IO.readlines(file).each do |line| return [$1.to_s, $2.to_s, $3.to_s] if line.match(/#{tag}(\w+), (\w+), (\w+)/) end end #---------------------------------------------------------------------------- # • Se é verdairo ou falo. #---------------------------------------------------------------------------- def of(file, tag) IO.readlines(file).each do |line| return $1.to_s == "true" ? true : false if line.match(/#{tag}([^>]*)/) end end end } #============================================================================== # * Window_Base #============================================================================== Dax.register(:window_base, "dax", 1.5) { if defined?("Window_Base") class Window_Base < Window #---------------------------------------------------------------------------- # • Slide pela direita. # * speed : Velocidade | point : Ponto da coordenada X que irá chegar. #---------------------------------------------------------------------------- def slide_right(speed, point) self.x += speed unless self.x >= point end #---------------------------------------------------------------------------- # • Slide pela esquerda. # * speed : Velocidade | point : Ponto da coordenada X que irá chegar. #---------------------------------------------------------------------------- def slide_left(speed, point) self.x -= speed unless self.x <= point end #---------------------------------------------------------------------------- # • Slide por cima. # * speed : Velocidade | point : Ponto da coordenada Y que irá chegar. #---------------------------------------------------------------------------- def slide_up(speed, point) self.y -= speed unless self.y <= point end #---------------------------------------------------------------------------- # • Slide por baixo. # * speed : Velocidade | point : Ponto da coordenada Y que irá chegar. #---------------------------------------------------------------------------- def slide_down(speed, point) self.y += speed unless self.y >= point end #---------------------------------------------------------------------------- # • Define aqui uma posição fixa para um objeto. # command : Retorna a uma base padrão. #---------------------------------------------------------------------------- def position(command=0) return if command.nil? Position[command, self] end end end } #============================================================================== # • Sound Base #============================================================================== Dax.register(:soundbase, "dax", 1.0) { module SoundBase #---------------------------------------------------------------------------- # • Função do módulo. #---------------------------------------------------------------------------- module_function #---------------------------------------------------------------------------- # • Executar um som. # name : Nome do som. # volume : Volume. # pitch : Pitch; #---------------------------------------------------------------------------- def play(name, volume, pitch, type = :se) case type when :se ; RPG::SE.new(name, volume, pitch).play rescue valid?(name) when :me ; RPG::ME.new(name, volume, pitch).play rescue valid?(name) when :bgm ; RPG::BGM.new(name, volume, pitch).play rescue valid?(name) when :bgs ; RPG::BGS.new(name, volume, pitch).play rescue valid?(name) end end #---------------------------------------------------------------------------- # • Validar som. #---------------------------------------------------------------------------- def valid?(name) raise("Arquivo de som não encontrado: #{name}") exit end end } #============================================================================== # • Benchmark #============================================================================== Dax.register(:benchmark, "Gotoken", 1.0) { module Benchmark extend self #---------------------------------------------------------------------------- # • Constantes. #---------------------------------------------------------------------------- CAPTION = " user system total real\n" FMTSTR = "%10.6u %10.6y %10.6t %10.6r\n" def Benchmark::times() # :nodoc: Process::times() end #---------------------------------------------------------------------------- # • Método do benchmark.:. # ** Exemplo:.: # n = 50000 # Benchmark.benchmark(" "*7 + CAPTION, 7, FMTSTR, ">total:", ">avg:") do |x| # tf = x.report("for:") { for i in 1..n; a = "1"; end } # tt = x.report("times:") { n.times do ; a = "1"; end } # tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end } # [tf+tt+tu, (tf+tt+tu)/3] # end # ** Gera:.: # user system total real # for: 1.016667 0.016667 1.033333 ( 0.485749) # times: 1.450000 0.016667 1.466667 ( 0.681367) # upto: 1.533333 0.000000 1.533333 ( 0.722166) # >total: 4.000000 0.033333 4.033333 ( 1.889282) # >avg: 1.333333 0.011111 1.344444 ( 0.629761) #---------------------------------------------------------------------------- def benchmark(caption = "", label_width = nil, fmtstr = nil, *labels) # :yield: report sync = STDOUT.sync STDOUT.sync = true label_width ||= 0 fmtstr ||= FMTSTR raise ArgumentError, "no block" unless iterator? print caption results = yield(Report.new(label_width, fmtstr)) Array === results and results.grep(Tms).each {|t| print((labels.shift || t.label || "").ljust(label_width), t.format(fmtstr)) } STDOUT.sync = sync end #---------------------------------------------------------------------------- # • Versão simplificada para benchmark. # ** Exemplo:.: # n = 50000 # Benchmark.bm(7) do |x| # x.report("for:") { for i in 1..n; a = "1"; end } # x.report("times:") { n.times do ; a = "1"; end } # x.report("upto:") { 1.upto(n) do ; a = "1"; end } # end # ** Gera:.: # user system total real # for: 1.050000 0.000000 1.050000 ( 0.503462) # times: 1.533333 0.016667 1.550000 ( 0.735473) # upto: 1.500000 0.016667 1.516667 ( 0.711239) #---------------------------------------------------------------------------- def bm(label_width = 0, *labels, &blk) # :yield: report benchmark(" "*label_width + CAPTION, label_width, FMTSTR, *labels, &blk) end #---------------------------------------------------------------------------- # • Retorna ao tempo usado para executar o bloco como um objeto Benchmark::Tms #---------------------------------------------------------------------------- def measure(label = "") # :yield: t0, r0 = Benchmark.times, Time.now yield t1, r1 = Benchmark.times, Time.now Benchmark::Tms.new(t1.utime - t0.utime, t1.stime - t0.stime, t1.cutime - t0.cutime, t1.cstime - t0.cstime, r1.to_f - r0.to_f, label) end #---------------------------------------------------------------------------- # • Retorna ao tempo real decorrido, o tempo usado para executar o bloco. #---------------------------------------------------------------------------- def realtime(&blk) # :yield: r0 = Time.now yield r1 = Time.now r1.to_f - r0.to_f end #============================================================================ # • Report :: #============================================================================ class Report #-------------------------------------------------------------------------- # • Retorna uma instância inicializada. # Usualmente não é bom chamar esse método diretamente. #-------------------------------------------------------------------------- def initialize(width = 0, fmtstr = nil) @width, @fmtstr = width, fmtstr end #-------------------------------------------------------------------------- # • Imprime o _label_ e o tempo marcado pelo bloco, formatado por _fmt_. #-------------------------------------------------------------------------- def item(label = "", *fmt, &blk) # :yield: print label.ljust(@width) res = Benchmark::measure(&blk) print res.format(@fmtstr, *fmt) res end #-------------------------------------------------------------------------- # • Método :alias: #-------------------------------------------------------------------------- alias :report :item end #============================================================================ # • Tms #============================================================================ class Tms #-------------------------------------------------------------------------- # • Constantes #-------------------------------------------------------------------------- CAPTION = " user system total real\n" FMTSTR = "%10.6u %10.6y %10.6t %10.6r\n" #-------------------------------------------------------------------------- # • Variáveis da instância. #-------------------------------------------------------------------------- attr_reader :utime # Tempo da CPU do Usuário. attr_reader :stime # Tempo da CPU do Sistema. attr_reader :cutime # Tempo da CPU do usuário-criança. attr_reader :cstime # Tempo da CPU do sistema-criança. attr_reader :real # Tempo real corrido. attr_reader :total # Tempo total, que é _utime_ + _stime_ + _cutime_ + _cstime_ attr_reader :label # Label. #-------------------------------------------------------------------------- # • Retorna ao objeto inicializado na qual tem _u_ como tempo dá CPU do # usuário, _s_ como o tempo da CPU do sistema, _cu_ como tempo dá CPU # do usuário-criança, _cs_ como o tempo dá CPU sistema-criança, _real_ # como o tempo real corrido e _l_ como label. #-------------------------------------------------------------------------- def initialize(u = 0.0, s = 0.0, cu = 0.0, cs = 0.0, real = 0.0, l = nil) @utime, @stime, @cutime, @cstime, @real, @label = u, s, cu, cs, real, l @total = @utime + @stime + @cutime + @cstime end #-------------------------------------------------------------------------- # • Retorna a um novo objeto Tms, na qual os tempos são somados num todo # pelo objeto Tms. #-------------------------------------------------------------------------- def add(&blk) # :yield: self + Benchmark::measure(&blk) end #-------------------------------------------------------------------------- # • Uma versão no lugar do método #add #-------------------------------------------------------------------------- def add! t = Benchmark::measure(&blk) @utime = utime + t.utime @stime = stime + t.stime @cutime = cutime + t.cutime @cstime = cstime + t.cstime @real = real + t.real self end #-------------------------------------------------------------------------- # • Soma com outro objeto do mesmo. #-------------------------------------------------------------------------- def +(other); memberwise(:+, other) end #-------------------------------------------------------------------------- # • Subtrai com outro objeto do mesmo. #-------------------------------------------------------------------------- def -(other); memberwise(:-, other) end #-------------------------------------------------------------------------- # • Multiplica com outro objeto do mesmo. #-------------------------------------------------------------------------- def *(x); memberwise(:*, x) end #-------------------------------------------------------------------------- # • Divide com outro objeto do mesmo. #-------------------------------------------------------------------------- def /(x); memberwise(:/, x) end #-------------------------------------------------------------------------- # • Retorna ao conteudo dos objetos formatados como uma string. #-------------------------------------------------------------------------- def format(arg0 = nil, *args) fmtstr = (arg0 || FMTSTR).dup fmtstr.gsub!(/(%[-+\.\d]*)n/){"#{$1}s" % label} fmtstr.gsub!(/(%[-+\.\d]*)u/){"#{$1}f" % utime} fmtstr.gsub!(/(%[-+\.\d]*)y/){"#{$1}f" % stime} fmtstr.gsub!(/(%[-+\.\d]*)U/){"#{$1}f" % cutime} fmtstr.gsub!(/(%[-+\.\d]*)Y/){"#{$1}f" % cstime} fmtstr.gsub!(/(%[-+\.\d]*)t/){"#{$1}f" % total} fmtstr.gsub!(/(%[-+\.\d]*)r/){"(#{$1}f)" % real} arg0 ? Kernel::format(fmtstr, *args) : fmtstr end #-------------------------------------------------------------------------- # • Mesmo que o método formato. #-------------------------------------------------------------------------- def to_s format end #-------------------------------------------------------------------------- # • Retorna a uma array contendo os elementos: # @label, @utime, @stime, @cutime, @cstime, @real #-------------------------------------------------------------------------- def to_a [@label, @utime, @stime, @cutime, @cstime, @real] end protected def memberwise(op, x) case x when Benchmark::Tms Benchmark::Tms.new(utime.__send__(op, x.utime), stime.__send__(op, x.stime), cutime.__send__(op, x.cutime), cstime.__send__(op, x.cstime), real.__send__(op, x.real) ) else Benchmark::Tms.new(utime.__send__(op, x), stime.__send__(op, x), cutime.__send__(op, x), cstime.__send__(op, x), real.__send__(op, x) ) end end CAPTION = Benchmark::Tms::CAPTION FMTSTR = Benchmark::Tms::FMTSTR end end } #============================================================================== # • Desativar scripts : Para fazer, basta por no nome do script da lista, # [D]. # • Salvar script em arquivo de texto : Para fazer, basta por no nome do script da lista, # [S]. #============================================================================== $RGSS_SCRIPTS.each_with_index { |data, index| if data.at(1).include?("[S]") File.open("#{rgss.at(1)}.txt", "wb") { |file| file.write(String($RGSS_SCRIPTS.at(index)[3])) file.close } end $RGSS_SCRIPTS.at(index)[2] = $RGSS_SCRIPTS.at(index)[3] = "" if data.at(1).include?("[D]") } #----------------------------------------------------------------------------- # • Carregar arquivo e executar. # path : Nome do arquivo. #----------------------------------------------------------------------------- def load_script(path) raise("Arquivo não encontrado %s" % path) unless FileTest.exist?(path) return eval(load_data(path)) if File.extname(path) == ".rvdata2" return eval(File.open(path).read) rescue nil end #============================================================================== # * Input #============================================================================== Dax.register(:input, "dax", 1.0) { class << Input alias :upft :update def update upft Key.update end end } #============================================================================== # • Graphics #============================================================================== Dax.register(:graphics, "dax", 1.0) { class << Graphics attr_reader :fps alias :uptf :update def update @fps ||= 0 @fps_temp ||= [] time = Time.now uptf Mouse.update @fps_temp[frame_count % frame_rate] = Time.now != time @fps = 0 frame_rate.times { |i| @fps.next if @fps_temp[i] } end end }