DocRock3r/infinitefusion-e18
1
0
Fork 0
mirror of https://github.com/infinitefusion/infinitefusion-e18.git synced 2025-12-08 05:34:58 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
cddcf220963b1c29e8da635058ee15118fc0bdc4
infinitefusion-e18/Data/Scripts/049_Compatibility/MarinUtilities.rb
infinitefusion cd906e7f1c various fixes
2022-10-29 17:27:55 -04:00

1286 lines
34 KiB
Ruby
Raw Blame History

# # # PluginManager.register({
# # # :name => "Marin's Scripting Utilities",
# # # :version => "1.5",
# # # :credits => "Marin",
# # # :link => "https://reliccastle.com/resources/165/"
# # # })
# #
# # # Whether or not you want the custom/better errors message.
# # SPECIAL_ERRORS = true
# #
# #
# #
# # # These two settings only apply if SPECIAL_ERRORS is TRUE
# #
# # DOUBLE_BACKTRACE = false # The interpreter already contains a small
# # # backtrace for errors in events and such by default.
# # # Settings this to false will not show the custom
# # # backtrace.
# #
# # BACKTRACE_MAX_SIZE = 12 # The backtrace can go all the way from the very first
# # # call to the very last call. This is the limit as far
# # # as it can go back, because you could have a massive
# # # backtrace otherwise.
# #
# #
# # class Object
# # def get_variables
# # return self.instance_variables.map { |v| [v,self.method(v.to_s.gsub(/@/, "").to_sym).call] }
# # end
# #
# # def set_variables(vars)
# # vars.each do |v|
# # self.method((v[0].to_s.gsub(/@/, "") + "=").to_sym).call(v[1])
# # end
# # end
# # end
# #
# # # E.g. PokeBattle_Pokemon -> to_sym -> :PokeBattle_Pokemon
# # class Class
# # def to_sym
# # return self.to_s.to_sym
# # end
# # end
# #
# # class NilClass
# # def empty?
# # return true
# # end
# #
# # def numeric?
# # return false
# # end
# # end
# #
# # class Numeric
# # # Formats the number nicely (e.g. 1234567890 -> format() -> 1,234,567,890)
# # def format(separator = ',')
# # a = self.to_s.split('').reverse.breakup(3)
# # return a.map { |e| e.join('') }.join(separator).reverse
# # end
# #
# # # Makes sure the returned string is at least n characters long
# # # (e.g. 4 -> to_digits -> "004")
# # # (e.g. 19 -> to_digits -> "019")
# # # (e.g. 123 -> to_digits -> "123")
# class Numeric
# def to_digits(n = 3)
# str = self.to_s
# return str if str.size >= n
# ret = ""
# (n - str.size).times { ret += "0" }
# return ret + str
# end
# end
#
# #
# # # n root of self. Defaults to 2 => square root.
# # def root(n = 2)
# # return (self ** (1.0 / n))
# # end
# #
# # # Factorial
# # # 4 -> fact -> (4 * 3 * 2 * 1) -> 24
# # def fact
# # raise ArgumentError, "Cannot execute factorial on negative numerics" if self < 0
# # tot = 1
# # for i in 2..self
# # tot *= i
# # end
# # return tot
# # end
# #
# # # Combinations
# # def ncr(k)
# # return (self.fact / (k.fact * (self - k).fact))
# # end
# #
# # # k permutations of n (self)
# # def npr(k)
# # return (self.fact / (self - k).fact)
# # end
# #
# # # Converts number to binary number (returns as string)
# # def to_b
# # return self.to_s(2)
# # end
# #
# # def empty?
# # return false
# # end
# #
# # def numeric?
# # return true
# # end
# # end
# #
# # class NilClass
# # def numeric?
# # return false
# # end
# # end
# #
# # # Calculates the total amount of elements in an Enumerable. Example:
# # # ["one","two","three"].fullsize #=> 11
# # module Enumerable
# # def fullsize
# # n = 0
# # for e in self
# # if e.is_a?(String)
# # n += e.size
# # elsif e.respond_to?(:fullsize)
# # n += e.fullsize
# # elsif e.respond_to?(:size) && !e.is_a?(Numeric)
# # n += e.size
# # else
# # n += 1
# # end
# # end
# # return n
# # end
# # end
# #
# # class Array
# # # Returns a random element of the array
# # def random
# # return self[Object.method(:rand).call(self.size)]
# # end
# #
# # # Returns whether or not the array is empty.
# # def empty?
# # return self.size == 0
# # end
# #
# # # Shuffles the order of the array
# # def shuffle
# # indexes = []
# # new = []
# # while new.size != self.size
# # # Weird way of calling rand for compatibility
# # # with Luka's scripting utilities
# # i = Object.method(:rand).call(self.size)
# # if !indexes.include?(i)
# # indexes << i
# # new << self[i]
# # end
# # end
# # return new
# # end
# #
# # # Shuffles the order of the array and replaces itself
# # def shuffle!
# # self.replace(shuffle)
# # end
# #
# # # Breaks the array up every n elements
# # def breakup(n)
# # ret = []
# # for i in 0...self.size
# # ret[(i / n).floor] ||= []
# # ret[(i / n).floor] << self[i]
# # end
# # return ret
# # end
# #
# # # Breaks the array up every n elements and replaces itself
# # def breakup!(n)
# # self.replace(breakup(n))
# # end
# #
# # # Swaps two elements' indexes
# # def swap(index1, index2)
# # new = self.clone
# # tmp = new[index2].clone
# # new[index2] = new[index1]
# # new[index1] = tmp
# # return new
# # end
# #
# # # Swaps two elements' indexes and replaces itself
# # def swap!(index1, index2)
# # self.replace(swap(index1, index2))
# # end
# #
# # # Returns whether or not the first element is equal to the passed argument
# # def starts_with?(e)
# # return self.first == e
# # end
# #
# # # Returns whether or not the last element is equal to the passed argument
# # def ends_with?(e)
# # return self.last == e
# # end
# #
# # # Converts itself to a hash where possible
# # def to_hash(delete_nil_entries = false)
# # ret = {}
# # for i in 0...self.size
# # next if self[i].nil? && delete_nil_entries
# # ret[i] = self[i]
# # end
# # return ret
# # end
# #
# # # If you have 8 elements, if true, grabs the 5th element, the 4th if false.
# # # If you have 7 elements, grabs the 4th.
# # def mid(round_up = true)
# # i = (self.size - 1) / 2.0
# # i = i.ceil if round_up
# # return self[i].floor
# # end
# #
# # # Returns the average of all elements in the array. Will throw errors on non-numerics.
# # # Skips <nil> entries.
# # def average
# # total = 0
# # self.each { |n| total += n unless n.nil? }
# # return total / self.compact.size.to_f
# # end
# #
# # # Adds some aliases for <include?>: <has?>, <includes?>, <contains?>
# # alias has? include?
# # alias includes? include?
# # alias contains? include?
# #
# # # Evaluates the block you pass it for every number between 0 and "slots".
# # # Example usage:
# # # Array.make_table { |i| i ** 2 }
# # # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# # # Array.make_table(10..16) { |i| i.to_s(2) }
# # # => ["1010", "1011", "1100", "1101", "1110", "1111", "10000"]
# # # (you can also pass it an array of values to iterate over)
# # def self.make_table(range = 1..10, &proc)
# # return range.map { |n| next proc.call(n) }
# # end
# #
# # # If true:
# # # [0, 1, 3, 4, 5] -- etc
# # # If false:
# # # [0,1,2,3,4,5] -- etc
# # Json_Extra_Space_After_Entry = false
# #
# # # Converts _self_ to a JSON string with an indent of Json_Indent_Width per layer.
# # def to_json(indent = Hash::Json_Indent_Width, inline = false)
# # return "[]" unless self.size > 0
# # full = "["
# # for i in 0...self.size
# # nl = false
# # if self[i].is_a?(Hash) || self[i].is_a?(Array)
# # val = self[i].to_json(indent + Hash::Json_Indent_Width, i == 0)
# # nl = !(inline && i == 0)
# # else
# # val = self[i]
# # val = "\"#{val}\"" if val.is_a?(String)
# # nl = (self.fullsize > 24 || self.map { |e| e.class.to_sym }.include?(:Hash))
# # end
# # full += "\n" + " " * indent if nl
# # full += val.to_s + ","
# # full += " " if Json_Extra_Space_After_Entry
# # end
# # i = 2 + Json_Extra_Space_After_Entry.to_i
# # full = full[0..(-i)]
# # full += "\n#{" " * (indent - Hash::Json_Indent_Width)}" if self.fullsize > 24 ||
# # self.map { |e| e.class.to_sym }.include?(:Hash)
# # full += "]"
# # return full
# # end
# # end
# #
# # class Hash
# # # Converts itself to an array where possible
# # def to_array(delete_nil_entries = false)
# # ret = []
# # keys = self.keys.sort
# # for key in keys
# # next if self[key].nil? && delete_nil_entries
# # ret[key] = self[key]
# # end
# # return ret
# # end
# #
# # def compact
# # new = {}
# # for key in self.keys
# # new[key] = self[key] unless self[key].nil?
# # end
# # return new
# # end
# #
# # def compact!
# # self.replace(compact)
# # end
# #
# # # Amount of spaces per "layer" in the JSON.
# # Json_Indent_Width = 4
# #
# # # Converts _self_ to a JSON string with an indent of Json_Indent_Width per layer.
# # def to_json(indent = Json_Indent_Width, _ = nil)
# # return "{}" if self.size == 0
# # full = "{"
# # keys = self.keys.sort do |a,b|
# # if $JSON_Sort_Order
# # if $JSON_Sort_Order.include?(a)
# # if $JSON_Sort_Order.include?(b)
# # next $JSON_Sort_Order.index(a) <=> $JSON_Sort_Order.index(b)
# # else
# # next -1
# # end
# # else
# # if $JSON_Sort_Order.include?(b)
# # next 1
# # end
# # # If neither are in the key, go alphabetical
# # end
# # end
# # if a.numeric?
# # if b.numeric?
# # next a <=> b
# # else
# # next -1
# # end
# # else
# # if b.numeric?
# # next 1
# # else
# # next a <=> b
# # end
# # end
# # end
# # for key in keys
# # if self[key].is_a?(Hash) || self[key].is_a?(Array)
# # val = self[key].to_json(indent + Json_Indent_Width, key == self.keys[0])
# # else
# # val = self[key]
# # val = "\"#{val}\"" if val.is_a?(String)
# # end
# # full += "\n#{" " * indent}\"#{key}\": #{val},"
# # end
# # full = full[0..-2]
# # full += "\n#{" " * (indent - Json_Indent_Width)}}"
# # return full
# # end
# # end
# #
# # # String class extensions
# # class String
# # # Converts to bits
# # def to_b
# # return self.unpack('b*')[0]
# # end
# #
# # # Converts to bits and replaces itself
# # def to_b!
# # self.replace(to_b)
# # end
# #
# # # Converts from bits
# # def from_b
# # return [self].pack('b*')
# # end
# #
# # # Convert from bits and replaces itself
# # def from_b!
# # self.replace(from_b)
# # end
# #
# # # Returns a random character from the string
# # def random
# # return self[rand(self.size)]
# # end
# #
# # # Shuffles the order of the characters
# # def shuffle
# # return self.split("").shuffle.join("")
# # end
# #
# # # Breaks the string up every _n_ characters
# # def breakup(n)
# # new = []
# # for i in 0...self.size
# # new[(i / n).floor] ||= ""
# # new[(i / n).floor] += self[i]
# # end
# # return new
# # end
# #
# # def empty?
# # return (self.size == 0)
# # end
# #
# # def numeric?
# # i = 0
# # for e in self.split("")
# # next if i == 0 && e == "-"
# # return false unless [0,1,2,3,4,5,6,7,8,9].map { |n| n.to_s }.include?(e)
# # end
# # return true
# # end
# #
# # # Deflates itself and returns the result
# # def deflate
# # return Zlib::Deflate.deflate(self)
# # end
# #
# # # Deflates and replaces itself
# # def deflate!
# # self.replace(deflate)
# # end
# #
# # # Inflates itself and returns the result
# # def inflate
# # return Zlib::Inflate.inflate(self)
# # end
# #
# # # Inflates and replaces itself
# # def inflate!
# # self.replace(inflate)
# # end
# #
# # # Adds some aliases for <include?>: <has?>, <includes?>, <contains?>
# # alias has? include?
# # alias includes? include?
# # alias contains? include?
# # end
# #
# # # File class extensions
# # class File
# # # Copies the source file to the destination path.
# # def self.copy(source, destination)
# # data = ""
# # t = Time.now
# # File.open(source, 'rb') do |f|
# # while r = f.read(4096)
# # if Time.now - t > 1
# # Graphics.update
# # t = Time.now
# # end
# # data += r
# # end
# # end
# # File.delete(destination) if File.file?(destination)
# # f = File.new(destination, 'wb')
# # f.write data
# # f.close
# # end
# #
# # # Renames the old file to be the new file. //exact same as File::move
# # def self.rename(old, new)
# # File.move(old, new)
# # end
# #
# # # Copies the source to the destination and deletes the source.
# # def self.move(source, destination)
# # File.copy(source, destination)
# # File.delete(source)
# # end
# #
# # # Reads the file's data and inflates it with Zlib
# # def self.inflate(file)
# # data = ""
# # t = Time.now
# # File.open(file, 'rb') do |f|
# # while r = f.read(4096)
# # if Time.now - t > 1
# # Graphics.update
# # t = Time.now
# # end
# # data += r
# # end
# # end
# # data.inflate!
# # File.delete(file)
# # f = File.new(file, 'wb')
# # f.write data
# # f.close
# # return data
# # end
# #
# # # Reads the file's data and deflates it with Zlib
# # def self.deflate(file)
# # data = ""
# # t = Time.now
# # File.open(file, 'rb') do |f|
# # while r = f.read(4096)
# # if Time.now - t > 1
# # Graphics.update
# # t = Time.now
# # end
# # data += r
# # end
# # end
# # data.deflate!
# # File.delete(file)
# # f = File.new(file, 'wb')
# # f.write data
# # f.close
# # return data
# # end
# #
# # # Note: This is VERY basic compression and should NOT serve as encryption.
# # # Compresses all specified files into one, big package
# # def self.compress(outfile, files, delete_files = true)
# # start = Time.now
# # files = [files] unless files.is_a?(Array)
# # for i in 0...files.size
# # if !File.file?(files[i])
# # raise "Could not find part of the path `#{files[i]}`"
# # end
# # end
# # files.breakup(500) # 500 files per compressed file
# # full = ""
# # t = Time.now
# # for i in 0...files.size
# # if Time.now - t > 1
# # Graphics.update
# # t = Time.now
# # end
# # data = ""
# # File.open(files[i], 'rb') do |f|
# # while r = f.read(4096)
# # if Time.now - t > 1
# # Graphics.update
# # t = Time.now
# # end
# # data += r
# # end
# # end
# # File.delete(files[i]) if delete_files
# # full += "#{data.size}|#{files[i]}|#{data}"
# # full += "|" if i != files.size - 1
# # end
# # File.delete(outfile) if File.file?(outfile)
# # f = File.new(outfile, 'wb')
# # f.write full.deflate
# # f.close
# # return Time.now - start
# # end
# #
# # # Decompresses files compressed with File.compress
# # def self.decompress(filename, delete_package = true)
# # start = Time.now
# # data = ""
# # t = Time.now
# # File.open(filename, 'rb') do |f|
# # while r = f.read(4096)
# # if Time.now - t > 1
# # Graphics.update
# # t = Time.now
# # end
# # data += r
# # end
# # end
# # data.inflate!
# # loop do
# # size, name = data.split('|')
# # data = data.split(size + "|" + name + "|")[1..-1].join(size + "|" + name + "|")
# # size = size.to_i
# # content = data[0...size]
# # data = data[(size + 1)..-1]
# # File.delete(name) if File.file?(name)
# # f = File.new(name, 'wb')
# # f.write content
# # f.close
# # break if !data || data.size == 0 || data.split('|').size <= 1
# # end
# # File.delete(filename) if delete_package
# # return Time.now - start
# # end
# #
# # # Creates all directories that don't exist in the given path, as well as the
# # # file. If given a second argument, it'll write that to the file.
# # def self.create(path, data = nil)
# # start = Time.now
# # Dir.create(path.split('/')[0..-2].join('/'))
# # f = File.new(path, 'wb')
# # f.write data if data && data.size > 0
# # f.close
# # return Time.now - start
# # end
# # end
# #
# # # Dir class extensions
# # class Dir
# # class << Dir
# # alias marin_delete delete
# # end
# #
# # # Returns all files in the targeted path
# # def self.get_files(path, recursive = true)
# # return Dir.get_all(path, recursive).select { |path| File.file?(path) }
# # end
# #
# # # Returns all directories in the targeted path
# # def self.get_dirs(path, recursive = true)
# # return Dir.get_all(path, recursive).select { |path| File.directory?(path) }
# # end
# #
# # # Returns all files and directories in the targeted path
# # def self.get_all(path, recursive = true)
# # files = []
# # Dir.foreach(path) do |f|
# # next if f == "." || f == ".."
# # if File.directory?(path + "/" + f) && recursive
# # files.concat(Dir.get_files(path + "/" + f))
# # end
# # files << path + "/" + f
# # end
# # return files
# # end
# #
# # # Deletes a directory and all files/directories within, unless non_empty is false
# # def self.delete(path, non_empty = true)
# # if non_empty
# # for file in Dir.get_all(path)
# # if File.directory?(file)
# # Dir.delete(file, non_empty)
# # elsif File.file?(file)
# # File.delete(file)
# # end
# # end
# # end
# # marin_delete(path)
# # end
# #
# # # Creates all directories that don't exist in the given path.
# # def self.create(path)
# # split = path.split('/')
# # for i in 0...split.size
# # Dir.mkdir(split[0..i].join('/')) unless File.directory?(split[0..i].join('/'))
# # end
# # end
# # end
# #
# #
# # Sprite class extensions
# class Sprite
# # Shorthand for initializing a bitmap by path, bitmap, or width/height:
# # -> bmp("Graphics/Pictures/bag")
# # -> bmp(32, 32)
# # -> bmp(some_other_bitmap)
# def bmp(arg1 = nil, arg2 = nil)
# if arg1
# if arg2
# arg1 = Graphics.width if arg1 == -1
# arg2 = Graphics.height if arg2 == -1
# self.bitmap = Bitmap.new(arg1, arg2)
# elsif arg1.is_a?(Bitmap)
# self.bitmap = arg1.clone
# else
# self.bitmap = Bitmap.new(arg1)
# end
# else
# return self.bitmap
# end
# end
#
# # Alternative to bmp(path):
# # -> bmp = "Graphics/Pictures/bag"
# def bmp=(arg1)
# bmp(arg1)
# end
#
# # Usage:
# # -> [x] # Sets sprite.x to x
# # -> [x,y] # Sets sprite.x to x and sprite.y to y
# # -> [x,y,z] # Sets sprite.x to x and sprite.y to y and sprite.z to z
# # -> [nil,y] # Sets sprite.y to y
# # -> [nil,nil,z] # Sets sprite.z to z
# # -> [x,nil,z] # Sets sprite.x to x and sprite.z to z
# # Etc.
# def xyz=(args)
# self.x = args[0] || self.x
# self.y = args[1] || self.y
# self.z = args[2] || self.z
# end
#
# # Returns the x, y, and z coordinates in the xyz=(args) format, [x,y,z]
# def xyz
# return [self.x, self.y, self.z]
# end
#
# # Centers the sprite by setting the origin points to half the width and height
# def center_origins
# return if !self.bitmap
# self.ox = self.bitmap.width / 2
# self.oy = self.bitmap.height / 2
# end
#
# # Returns the sprite's full width, taking zoom_x into account
# def fullwidth
# return self.bitmap.width.to_f * self.zoom_x
# end
#
# # Returns the sprite's full height, taking zoom_y into account
# def fullheight
# return self.bitmap.height.to_f * self.zoom_y
# end
# end
#
# #
# class TextSprite < Sprite
# # Sets up the sprite and bitmap. You can also pass text to draw
# # either an array of arrays, or an array containing the normal "parameters"
# # for drawing text:
# # [text,x,y,align,basecolor,shadowcolor]
# def initialize(viewport = nil, text = nil, width = -1, height = -1)
# super(viewport)
# @width = width
# @height = height
# self.bmp(@width, @height)
# pbSetSystemFont(self.bmp)
# if text.is_a?(Array)
# if text[0].is_a?(Array)
# pbDrawTextPositions(self.bmp, text)
# else
# pbDrawTextPositions(self.bmp, [text])
# end
# end
# end
#
# # Clears the bitmap (and thus all drawn text)
# def clear
# self.bmp.clear
# pbSetSystemFont(self.bmp)
# end
#
# # You can also pass text to draw either an array of arrays, or an array
# # containing the normal "parameters" for drawing text:
# # [text,x,y,align,basecolor,shadowcolor]
# def draw(text, clear = false)
# self.clear if clear
# if text[0].is_a?(Array)
# pbDrawTextPositions(self.bmp, text)
# else
# pbDrawTextPositions(self.bmp, [text])
# end
# end
#
# # Draws text with outline
# # [text,x,y,align,basecolor,shadowcolor]
# def draw_outline(text, clear = false)
# self.clear if clear
# if text[0].is_a?(Array)
# for e in text
# e[2] -= 224
# pbDrawOutlineText(self.bmp, e[1], e[2], 640, 480, e[0], e[4], e[5], e[3])
# end
# else
# e = text
# e[2] -= 224
# pbDrawOutlineText(self.bmp, e[1], e[2], 640, 480, e[0], e[4], e[5], e[3])
# end
# end
#
# # Draws and breaks a line if the width is exceeded
# # [text,x,y,width,numlines,basecolor,shadowcolor]
# def draw_ex(text, clear = false)
# self.clear if clear
# if text[0].is_a?(Array)
# for e in text
# drawTextEx(self.bmp, e[1], e[2], e[3], e[4], e[0], e[5], e[6])
# end
# else
# e = text
# drawTextEx(self.bmp, e[1], e[2], e[3], e[4], e[0], e[5], e[6])
# end
# end
#
# # Clears and disposes the sprite
# def dispose
# clear
# super
# end
# end
#
# # A better alternative to the typical @sprites = {}
# class SpriteHash
# attr_reader :x
# attr_reader :y
# attr_reader :z
# attr_reader :visible
# attr_reader :opacity
#
# def initialize
# @hash = {}
# @x = 0
# @y = 0
# @z = 0
# @visible = true
# @opacity = 255
# end
#
# # Returns the object in the specified key
# def [](key)
# key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
# return @hash[key]
# end
#
# # Sets an object in specified key to the specified value
# def []=(key, value)
# key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
# add(key, value)
# end
#
# # Returns the raw hash
# def raw
# return @hash
# end
#
# # Returns the keys in the hash
# def keys
# return @hash.keys
# end
#
# def length
# return self.size;
# end
#
# def count
# return self.size;
# end
#
# # Returns the amount of keys in the hash
# def size
# return @hash.keys.size
# end
#
# # Clones the hash
# def clone
# return @hash.clone
# end
#
# # Adds an object to the specified key
# def add(key, value)
# clear_disposed
# key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
# @hash[key] if @hash[key] && @hash[key].respond_to?(:dispose)
# @hash[key] = value
# clear_disposed
# end
#
# # Deletes an object in the specified key
# def delete(key)
# key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric)
# @hash[key] = nil
# clear_disposed
# end
#
# # Iterates over all sprites
# def each
# clear_disposed
# @hash.each { |s| yield s[1] if block_given? }
# end
#
# # Updates all sprites
# def update
# clear_disposed
# for key in @hash.keys
# @hash[key].update if @hash[key].respond_to?(:update)
# end
# end
#
# # Disposes all sprites
# def dispose
# clear_disposed
# for key in @hash.keys
# @hash[key].dispose if @hash[key].respond_to?(:dispose)
# end
# clear_disposed
# end
#
# # Compatibility
# def disposed?
# return false
# end
#
# # Changes x on all sprites
# def x=(value)
# clear_disposed
# for key in @hash.keys
# @hash[key].x += value - @x
# end
# @x = value
# end
#
# # Changes y on all sprites
# def y=(value)
# clear_disposed
# for key in @hash.keys
# @hash[key].y += value - @y
# end
# @y = value
# end
#
# # Changes z on all sprites
# def z=(value)
# clear_disposed
# for key in @hash.keys
# @hash[key].z += value - @z
# end
# @z = value
# end
#
# # Changes visibility on all sprites
# def visible=(value)
# clear_disposed
# for key in @hash.keys
# @hash[key].visible = value
# end
# end
#
# # Changes opacity on all sprites
# def opacity=(value)
# clear_disposed
# for key in @hash.keys
# @hash[key].opacity += value - @opacity
# end
# @opacity = [0, value, 255].sort[1]
# end
#
# # Fades out all sprites
# def hide(frames = 16)
# clear_disposed
# frames.times do
# Graphics.update
# Input.update
# for key in @hash.keys
# @hash[key].opacity -= 255 / frames.to_f
# end
# end
# @opacity = 0
# end
#
# # Fades in all sprites
# def show(frames = 16)
# clear_disposed
# frames.times do
# Graphics.update
# Input.update
# for key in @hash.keys
# @hash[key].opacity += 255 / frames.to_f
# end
# end
# @opacity = 255
# end
#
# # Deletes all disposed sprites from the hash
# def clear_disposed
# for key in @hash.keys
# if (@hash[key].disposed? rescue true)
# @hash[key] = nil
# @hash.delete(key)
# end
# end
# end
#
# # Renames the old key to the new key
# def rename(old, new)
# self[new] = self[old]
# delete(old)
# end
# end
#
# class ByteWriter
# def initialize(filename)
# @file = File.new(filename, "wb")
# end
#
# def <<(*data)
# write(*data)
# end
#
# def write(*data)
# data.each do |e|
# if e.is_a?(Array)
# e.each { |item| write(item) }
# elsif e.is_a?(Numeric)
# @file.putc e
# else
# raise "Invalid data for writing."
# end
# end
# end
#
# def write_int(int)
# self << ByteWriter.to_bytes(int)
# end
#
# def close
# @file.close
# @file = nil
# end
#
# def self.to_bytes(int)
# return [
# (int >> 24) & 0xFF,
# (int >> 16) & 0xFF,
# (int >> 8) & 0xFF,
# int & 0xFF
# ]
# end
# end
#
# class Bitmap
# def save_to_png(filename)
# f = ByteWriter.new(filename)
#
# #============================= Writing header ===============================#
# # PNG signature
# f << [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]
# # Header length
# f << [0x00, 0x00, 0x00, 0x0D]
# # IHDR
# headertype = [0x49, 0x48, 0x44, 0x52]
# f << headertype
#
# # Width, height, compression, filter, interlacing
# headerdata = ByteWriter.to_bytes(self.width).
# concat(ByteWriter.to_bytes(self.height)).
# concat([0x08, 0x06, 0x00, 0x00, 0x00])
# f << headerdata
#
# # CRC32 checksum
# sum = headertype.concat(headerdata)
# f.write_int Zlib::crc32(sum.pack("C*"))
#
# #============================== Writing data ================================#
# data = []
# for y in 0...self.height
# # Start scanline
# data << 0x00 # Filter: None
# for x in 0...self.width
# px = self.get_pixel(x, y)
# # Write raw RGBA pixels
# data << px.red
# data << px.green
# data << px.blue
# data << px.alpha
# end
# end
# # Zlib deflation
# smoldata = Zlib::Deflate.deflate(data.pack("C*")).bytes.map
# # data chunk length
# f.write_int smoldata.size
# # IDAT
# f << [0x49, 0x44, 0x41, 0x54]
# f << smoldata
# # CRC32 checksum
# f.write_int Zlib::crc32([0x49, 0x44, 0x41, 0x54].concat(smoldata).pack("C*"))
#
# #============================== End Of File =================================#
# # Empty chunk
# f << [0x00, 0x00, 0x00, 0x00]
# # IEND
# f << [0x49, 0x45, 0x4E, 0x44]
# # CRC32 checksum
# f.write_int Zlib::crc32([0x49, 0x45, 0x4E, 0x44].pack("C*"))
# f.close
# return nil
# end
# end
#
# # Stand-alone methods
#
# # Fades in a black overlay
# def showBlk(n = 16)
# return if $blkVp || $blk
# $blkVp = Viewport.new(0, 0, Settings::SCREEN_WIDTH, Settings::SCREEN_HEIGHT)
# $blkVp.z = 9999999
# $blk = Sprite.new($blkVp)
# $blk.bmp(-1, -1)
# $blk.bitmap.fill_rect(0, 0, Settings::SCREEN_WIDTH, Settings::SCREEN_HEIGHT, Color.new(0, 0, 0))
# $blk.opacity = 0
# for i in 0...(n + 1)
# Graphics.update
# Input.update
# yield i if block_given?
# $blk.opacity += 256 / n.to_f
# end
# end
#
# # Fades out and disposes a black overlay
# def hideBlk(n = 16)
# return if !$blk || !$blkVp
# for i in 0...(n + 1)
# Graphics.update
# Input.update
# yield i if block_given?
# $blk.opacity -= 256 / n.to_f
# end
# $blk.dispose
# $blk = nil
# $blkVp.dispose
# $blkVp = nil
# end
#
# # Returns the percentage of exp the Pokémon has compared to the next level
# # def pbGetE
# # xpPercentage(pokemon)
# # pokemon = pokemon.pokemon if pokemon.respond_to?("pokemon")
# # startexp = PBExperience.pbGetStartExperience(pokemon.level, pokemon.growthrate)
# # endexp = PBExperience.pbGetStartExperience(pokemon.level + 1, pokemon.growthrate)
# # return (pokemon.exp - startexp).to_f / (endexp - startexp).to_f
# # end
#
# # unless defined?(oldrand)
# # alias oldrand rand
# # def rand(a = nil, b = nil)
# # if a.is_a?(Range)
# # l = a.min
# # u = a.max
# # return l + oldrand(u - l + 1)
# # elsif a.is_a?(Numeric)
# # if b.is_a?(Numeric)
# # return a + oldrand(b - a)
# # else
# # return oldrand(a)
# # end
# # elsif a.nil?
# # if b
# # return rand(b)
# # else
# # return oldrand(2)
# # end
# # end
# # end
# # end
#
# # Input module extensions
# # module Input
# # # Returns true if any of the buttons below are pressed
# # def self.any?
# # return true if defined?(Game_Mouse) && $mouse && $mouse.click?
# # keys = [Input::C,Input::B,Input::LEFT,Input::RIGHT,Input::UP,Input::DOWN,
# # # 0-9, a-z
# # 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,
# # 0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x50,0x51,0x52,0x53,
# # 0x54,0x55,0x56,0x57,0x58,0x59,0x5A]
# # for key in keys
# # return true if Input.triggerex?(key)
# # end
# # return false
# # end
# # end
#
# #
# # if SPECIAL_ERRORS
# #
# # MessageBox = Win32API.new('user32', 'MessageBox', ['I','P','P','I'], 'I')
# #
# # def p_msg(msg, title = nil, icon = nil)
# # case icon
# # when :error, :err
# # uType = 0x10
# # title ||= "Error"
# # when :q, :question, :ask
# # uType = 0x20
# # title ||= "Question"
# # when :warning, :warn
# # uType = 0x30
# # title ||= "Warning"
# # when :inform, :info, :information
# # uType = 0x40
# # title ||= "Info"
# # else
# # uType = 0
# # title ||= "Pokémon"
# # end
# # hwnd = Win32API.pbFindRgssWindow
# # Graphics.update
# # t = Thread.new { MessageBox.call(hwnd, msg, title, uType); Thread.exit }
# # while t.status
# # Graphics.update
# # end
# # end
# #
# # def p_err(ex = $!, message = nil)
# # if $Rescue
# # raise
# # return
# # end
# # if ex.is_a?(String)
# # ex = RuntimeError.new ex
# # elsif ex.is_a?(Class)
# # ex = ex.new
# # end
# # trace = ex.backtrace || caller
# # script_id = trace[0][7..-1].split(':')[0].to_i
# # script = $RGSS_SCRIPTS[script_id][1]
# # line = trace[0].split(':')[1].to_i
# # msg = "Script '[#{script}]' line #{line}: #{ex.class} occurred."
# # if message || ex.message != ex.class.to_s
# # if message
# # msg << "\n\n#{message}"
# # else
# # msg << "\n\n#{ex.message}"
# # message = ex.message
# # end
# # end
# # showtrace = (trace.size > 2)
# # showtrace = false if !DOUBLE_BACKTRACE && message.include?(':in `')
# # if showtrace
# # msg << "\n\n"
# # msg << trace[0...BACKTRACE_MAX_SIZE].map do |e|
# # sID = e.split(':')[0][7..-1]
# # if sID && sID.numeric?
# # sID = sID.to_i
# # s = "'" + $RGSS_SCRIPTS[sID][1] + "'"
# # else
# # s = "eval"
# # end
# # line = e.split(':')[1].to_i
# # code = e.split(':')[2..-1].join(':')
# # str = "from #{s} line #{line}"
# # str << " #{code}" unless code.empty?
# # next str
# # end.join("\n")
# # end
# # p_msg(msg, "Error", :err)
# # Kernel.exit! true
# # end
# #
# # def p_info(msg, title = nil)
# # p_msg(msg, title, :info)
# # end
# #
# # def p_warn(msg, title = nil)
# # p_msg(msg, title, :warn)
# # end
# #
# # def p_question(msg, title = nil)
# # p_msg(msg, title, :question)
# # end
# #
#
#
# #
# # else
# #
# # def p_err(*args)
# # raise *args
# # end
# #
# # end # if SPECIAL_ERRORS
#
# # def pbGetActiveEventPage(event, mapid = nil)
# # mapid ||= event.map.map_id if event.respond_to?(:map)
# # pages = (event.is_a?(RPG::Event) ? event.pages : event.instance_eval { @event.pages })
# # for i in 0...pages.size
# # c = pages[pages.size - 1 - i].condition
# # ss = !(c.self_switch_valid && !$game_self_switches[[mapid,
# # event.id,c.self_switch_ch]])
# # sw1 = !(c.switch1_valid && !$game_switches[c.switch1_id])
# # sw2 = !(c.switch2_valid && !$game_switches[c.switch2_id])
# # var = true
# # if c.variable_valid
# # if !c.variable_value || !$game_variables[c.variable_id].is_a?(Numeric) ||
# # $game_variables[c.variable_id] < c.variable_value
# # var = false
# # end
# # end
# # if ss && sw1 && sw2 && var # All conditions are met
# # return pages[pages.size - 1 - i]
# # end
# # end
# # return nil
# # end
Reference in New Issue View Git Blame Copy Permalink