#==============================================================================
# ** Drago - Core Engine
# Version : 1.59
# Contact : littledrago.blogspot.com / forum.chaos-project.com
#==============================================================================
($imported ||= {})[:drg_core_engine] = 1.59
# =============================================================================
# NOTE:
# -----------------------------------------------------------------------------
# This is a devtool for me to make me easier for scripting
# If you want to use this, put above all custom script & below Scene_Debug
#
# =============================================================================
# DOCUMENTATION:
# -----------------------------------------------------------------------------
=begin
Version History
1.57 -
▼ Overhaul script (108 minor modification)
▼ Fixed glitch on BitmapDump method
▼ Added Bitmap#rotate90
▼ Added Bitmap#rotate180
▼ Added Bitmap#rotate270
1.50 -
▼ Overhaul script (71 minor modification)
▼ Longer script call (RMXP script call bug fix)
1.42 -
▼ Fixed Graphics.fullscreen?
1.40 -
▼ Modified Game_Map#load_event
1.39 -
▼ Fixed glitch at Bitmap#draw_icon
▼ Added Fiber class
▼ Added Game_Map#load_event
▼ Added Game_Map#call_event
1.36 -
▼ Added Color class library
1.34 -
▼ Added Module#define_third_method(sym = nil, _alias = nil,
prevent_stack = true, *a, &block)
▼ Added Bitmap#blur
1.31 -
▼ Added Module#attr_sec_reader(symbol, default=0)
▼ Added Module#attr_sec_accessor(symbol, *a, &block)
▼ Added Module#alias_sec_method(sym = nil, *a, &block)
▼ Added Module#define_sec_method(sym = nil, *a, &block)
1.29 -
▼ Added Array#have_all?(array)
▼ Added Array#have_any?(array)
1.27 -
▼ Added Added Graphics.brightness
▼ Added Graphics.wait(frames = 10)
▼ Added Graphics.fadein(frames = 10)
▼ Added Graphics.fadeout(frames = 10)
▼ Added Bitmap#invert
▼ Added Bitmap#invert!
▼ Added Bitmap#brighten(amount = 10)
▼ Added Bitmap#brighten!(amount = 10)
▼ Added Bitmap#darken(amount = 10)
▼ Added Bitmap#darken!(amount = 10)
▼ Added Bitmap#grayscale
▼ Added Bitmap#grayscale!
▼ Added Bitmap#pixelate(size = 10)
▼ Added Bitmap#pixelate!(size = 10)
▼ Added Bitmap#frost(noise = 10)
▼ Added Bitmap#frost!(noise = 10)
1.24 -
▼ Added Viewport#x
▼ Added Viewport#y
▼ Added Viewport#width
▼ Added Viewport#height
▼ Added Viewport#disposed?
1.23 -
▼ Added Window_Base#draw_text (same as Bitmap#draw_text)
▼ Added Window_Base#draw_icon
▼ Added Window_Base#draw_battler
▼ Added Window_Base#draw_picture
1.22 -
▼ Added Game_Map#load_map_data
▼ Added Game_Map#load_event
▼ Rename Array#product => Array#prod (because of conflict with RGSS3)
1.21 -
▼ Fixed Glitch at Bitmap#crop
1.20 -
▼ Fixed Script Hanging Error at Bitmap#export
1.19 -
▼ Added some of RMXP method - Game_System#play_bgm
▼ Added some of RMXP method - Game_System#play_bgs
▼ Added some of RMXP method - Game_System#play_me
▼ Added some of RMXP method - Game_System#play_se
1.18 -
▼ Fixing Backtrace at Array#method_missing
1.17 -
▼ Added Bitmap#flip_vertical
▼ Added Bitmap#flip_vertical!
▼ Added Bitmap#flip_horizontal
▼ Added Bitmap#flip_horizontal!
1.16 -
▼ Added Bitmap#export (dump bitmap into .png files)
1.15 -
▼ Added Game_Characters#character_above?
▼ Added Game_Characters#character_below?
▼ Added Game_Characters#character_right?
▼ Added Game_Characters#character_left?
1.11 -
▼ Fixing Bug at changing screen size
1.10 -
▼ Added Graphics.scale_screen(width, height)
1.00 -
▼ Original Release
# -----------------------------------------------------------------------------
# Below is the available command in this script
# -----------------------------------------------------------------------------
# * Graphics
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
This command is not recommended to used in RMXP
Graphics.scale_screen(width,height)
- Resize the screen and stretched it (if not RMXP) into new resolution
Graphics.fill_monitor
- Maximize the screen and stretched it (if not RMXP) to fill the monitor
Graphics.control_screen_size(enable = true)
- Enable or disable screen size control by mouse.
Resized screen will be stretched (if not RMXP)
# -----------------------------------------------------------------------------
Graphics.width - Returns screen width
Graphics.height - Returns screen height
Graphics.fullscreen? - Returns true if Game in fullscreen mode, else false
Graphics.fullscreen - Switch to fullscreen mode
Graphics.window - Switch to windowed mode
Graphics.toggle - Switch between fullscreen mode and windowed mode
Graphics.wait(frame) - Wait for frame
Graphics.wait_for_input - Wait until input is pressed
Graphics.fadein(frame) - Fade in the screen
Graphics.fadeout(frame) - Fade out the screen
Graphics.snap_to_bitmap - Snap screen to a bitmap object
Graphics.high_priority = true/false - Change process priority to high / normal
Graphics.disable_alt_enter - Disable input ALT+Enter (until game is closed)
# -----------------------------------------------------------------------------
# * Module
# -----------------------------------------------------------------------------
Module#attr_sec_reader(symbol, default=0)
- Create attr_reader with default value
Example : attr_sec_reader :something, "Sprite.new"
Equal : def something
@something ||= Sprite.new
end
Module#attr_sec_accessor(symbol, *a, &block)
- Create (sheer of) attr_accessor with default value
Example : attr_sec_accessor :sprite1, :sprite2, :sprite3, "Sprite.new"
Equal : attr_writer :sprite1, :sprite2, :sprite3
attr_sec_reader :sprite1, "Sprite.new"
attr_sec_reader :sprite2, "Sprite.new"
attr_sec_reader :sprite3, "Sprite.new"
Module#alias_sec_method(sym = nil, *a, &block)
- Create alias only if alias name is not defined and target method is exist
Example : alias_sec_method :alias_method, :target_method
Equal : if method_defined?(:target) && !method_defined?(:alias)
alias_method :alias, :target
end
Module#define_sec_method(sym = nil, *a, &block)
- Define method only if the method is not defined
Example : define_sec_method(:some_method) { |*a| block }
Equal : unless method_defined?(:some_method)
def some_method(*a)
block
end
end
# -----------------------------------------------------------------------------
# * Array
# -----------------------------------------------------------------------------
Array Method Distributor
- Distribute unexisted method in array into each variable
(will work only if the method isn't exist in Array)
Example : [Graphics,Input].update
# equal => Graphics.update ; Input.update
[@string1,@string2,@integer1,@sprite].dispose
# equal => @sprite.dispose
# (all variable without dispose method is ignored)
[@string1,@string2,@integer1].dispose
# Throws NoMethodError if all method didn't have dispose method
Array#random_each / Array#random_each_with_index
Example : a = [1,2,3,4,5,6,7]
a.random_each {|i| puts i} # 4,5,3,2,7,1,6
Array#sum
Array#prod
Array#average
Example : [1,2,3,4].sum # 10 (1+2+3+4)
[1,2,3,4].average # 2.5 (10 / 4)
[1,2,3,4].prod # 24 (1*2*3*4)
Array#shuffle / Array#shuffle!
Example : [1,2,3,4].shuffle # [3,2,4,1]
Array#random / Array#random!
Example : [1,2,3,4].random # 3
Array#switch=(true/false)
Array#switch_reverse
- Turn on / off switches all variable in the array
(will ignored if variable not integer or not an array)
Example : [1,2,[3,2,'A'],5].switch = true
# equal => $game_switches[1] = true
$game_switches[2] = true
$game_self_switches[[3,2,'A']] = true
$game_switches[5] = true
Array#variable(value = nil, method = "=")
- Change all variable value in the array (ignored if variable not integer)
Example : [1,2,5].variable(10)
# equal => $game_variables[1] = 10
$game_variables[2] = 10
$game_variables[5] = 10
Example : [1,2,5].variable(10, "+=")
# equal => $game_variables[1] += 10
$game_variables[2] += 10
$game_variables[5] += 10
Array#have_all?(array)
- returns true if contains all elements of the array
Array#have_any?(array)
- returns true if contains any elements of the array
# -----------------------------------------------------------------------------
# * Sprite
# -----------------------------------------------------------------------------
Sprite#clone
Sprite#dup
- Clone sprite without "can't clone sprite error"
Example : a = Sprite.new
b = a.clone
a.dispose
print a.disposed? # true
print b.disposed? # false
# -----------------------------------------------------------------------------
# * Spriteset_Map
# -----------------------------------------------------------------------------
Spriteset_Map#sprite_player
- returns sprite player at @character_sprites in Spriteset_Map
Spriteset_Map#find_character(character)
- returns character sprite at @character_sprites in Spriteset_Map
# -----------------------------------------------------------------------------
# * Game Battler
# -----------------------------------------------------------------------------
Game_Battler#hp_percent(integer = false, float_points = 2)
Game_Battler#sp_percent(integer = false, float_points = 2)
Example : $game_actors[1].hp_percent
# returns 0 - 100 based on percentage hp
# -----------------------------------------------------------------------------
# * Bitmap
# -----------------------------------------------------------------------------
Bitmap#export(filename)
- exporting bitmap into a file (only support bmp and png)
Example : bitmap = Bitmap.new(50,20)
bitmap.export('empty.png')
Bitmap#flip_vertical
Bitmap#flip_vertical!
Bitmap#flip_horizontal
Bitmap#flip_horizontal!
- flip the bitmap vertically or horizontally (using ! will modify self)
Example : bitmap = Bitmap.new(50,20)
bitmap.flip_vertical!
Bitmap#rotate90
Bitmap#rotate90!
Bitmap#rotate180
Bitmap#rotate180!
Bitmap#rotate270
Bitmap#rotate270!
Additional Bitmap Effects
Note : calling this method is process consuming, use with caution
Bitmap#invert
Bitmap#invert!
Bitmap#brighten(amount = 10)
Bitmap#brighten!(amount = 10)
Bitmap#darken(amount = 10)
Bitmap#darken!(amount = 10)
Bitmap#grayscale
Bitmap#grayscale!
Bitmap#pixelate(size = 10)
Bitmap#pixelate!(size = 10)
Bitmap#frost(noise = 10)
Bitmap#frost!(noise = 10)
# -----------------------------------------------------------------------------
# * Color
# -----------------------------------------------------------------------------
Color RGB value shortcut
List :
Color.red
Color.green
Color.blue
Color.white
Color.black
Color.yellow
Color.magenta
Color.cyan
Color.purple
Color.gray
Color.lightgray
Color.darkgray
Color.pink
Color.orange
Color.brown
Color.golden
Color.invert
Color Hex
- You can use hex value as method in color class (not case sensitive)
(need to include 'x' in front)
Example : Color.xffffff, Color.x04dacf, etc
# -----------------------------------------------------------------------------
# * Game_Map
# -----------------------------------------------------------------------------
Game_Map#load_event(mapid, eventid, x, y, page_id)
Game_Map#load_event(mapid, eventid, x, y)
Game_Map#load_event(eventid, x, y) # map_id will be assumed as current map
- Duplicate an event from another map to current map at position (x, y)
Game_Map#call_event(mapid, eventid, page_id)
Game_Map#call_event(mapid, eventid) # page_id will be assumed as -1
Game_Map#call_event(eventid) # map_id will be assumed as current map
- Call an event from another map to current map
Note that page_id is start from 1, not 0
If you're using RMVX or RMVXA, setting page_id to -1 will bring you to
the page with met condition.
# -----------------------------------------------------------------------------
# * RTP fix
# -----------------------------------------------------------------------------
Longer script call
- You can stack script call next to each other as many as possible and they
will be connected.
- In addition, this also fixes the Interpreter Script call bug when if you
use $game_system..... = false, game would freeze. This will prevent that.
# -----------------------------------------------------------------------------
# * End Documentation
# -----------------------------------------------------------------------------
=end
# =============================================================================
#==============================================================================
# ** Module
#------------------------------------------------------------------------------
#
#==============================================================================
class Module
#-------------------------------------------------------------------------
# * New method: attr_sec_reader (Attr Secondary Reader)
#-------------------------------------------------------------------------
unless method_defined?(:attr_sec_reader)
def attr_sec_reader(*sym)
if (1..2) === sym.size
module_eval("define_method(:#{sym[0]}) { @#{sym[0]} ||= #{sym[1]||0}}")
elsif sym.size > 2
(default = sym.pop) && sym.each {|s| attr_sec_reader(s,default)}
end
end
end
#-------------------------------------------------------------------------
# * New method: attr_sec_accessor (Attr Secondary Accessor)
#-------------------------------------------------------------------------
def attr_sec_accessor(sym = nil, *args)
(args.size > 0) | sym.nil? || args.push(0)
(default = args.pop) && (b = [sym].concat(args).compact)
(b).each {|a| (attr_writer(a) || 0) && attr_sec_reader(a,default)}
end
#-------------------------------------------------------------------------
# * New method: alias_sec_method (Alias Secondary Method)
# Note : This method will create alias only if alias name is not defined
# and target alias is exist
#-------------------------------------------------------------------------
unless method_defined?(:alias_sec_method)
private
def alias_sec_method(sym = nil, *args)
(args.size > 0) | sym.nil? || args.clear
(t = args.pop) && (b = [sym].concat(args).compact).each do |a|
c = (t == :initialize ? true : method_defined?(t))
method_defined?(a) || (c && alias_method(a, t))
end
end
end
#-------------------------------------------------------------------------
# * New method: redirect_method
#-------------------------------------------------------------------------
unless method_defined?(:redirect_method)
private
def redirect_method(sym = nil, *args, &block)
(args.size > 0) | sym.nil? || args.clear
(t = args.pop) && (b = [sym].concat(args).compact).each do |a|
meth = "def #{a}[*args] #{t}(*args) end"
meth.gsub!(/(['")}\](\d+)])\(\*args\)/i) { $1 }#'
meth.gsub!(/\[\*args\]/i) { '(*args)' }
method_defined?(a) || module_eval(meth)
end
end
end
#-------------------------------------------------------------------------
# * New method: define_sec_method
# Note : This method will not defining method if method name already
# exist
#-------------------------------------------------------------------------
unless method_defined?(:define_sec_method)
private
def define_sec_method(sym = nil, *args, &block)
sym && (method_defined?(s = sym.to_sym) || define_method(s,*args,&block))
end
end
#-------------------------------------------------------------------------
# * New method: define_third_method
# Note : After aliasing, define a method
#-------------------------------------------------------------------------
unless method_defined?(:define_third_method)
private
def define_third_method(sym = nil, _alias = nil, *args, &block)
unless sym.nil? || _alias.nil?
stack = _alias.to_s =~ /stack/i || sym.to_s == 'initialize'
stack = (!stack && method_defined?(_alias.to_sym))
stack || alias_method(_alias.to_sym, sym.to_sym)
define_method(sym.to_sym,*args,&block)
end
end
end
#--------------------------------------------------------------------------
# ● New method: define_pre_alias
#--------------------------------------------------------------------------
unless method_defined?(:define_pre_method)
private
def define_pre_alias(sym = nil, *args, &block)
_time = Time.now
_alias = :"#{sym}_#{_time.to_i}_#{_time.usec}"
define_third_method(:"#{sym}",_alias) do |*args|
block.bind(self).call
send(_alias,*args)
end
end
private
def define_post_alias(sym = nil, *args, &block)
_time = Time.now
_alias = :"#{sym}_#{_time.to_i}_#{_time.usec}"
define_third_method(:"#{sym}",_alias) do |*args|
send(_alias,*args)
block.bind(self).call
end
end
end
#--------------------------------------------------------------------------
# ● New method: include_auto_update
#--------------------------------------------------------------------------
unless method_defined?(:include_auto_update)
private
def include_auto_update
return if method_defined?(:update_auto_update)
attr_sec_accessor(:auto_update, "[]")
define_method(:update_auto_update) do
return if auto_update.empty?
auto_update.each do |x|
(x[1].nil? ? send(x[0]) : (x[2].nil? ? x[0].method(x[1]).call :
(x[0].method(x[1]).call(*x[2]))))
(x[3].is_a?(Numeric) && (x[3] -= 1))
end
auto_update.reject! {|x| x[3].is_a?(Numeric) && x[3] <= 0 }
end
_time = Time.now
_alias = :"update_#{_time.to_i}_#{_time.usec}"
define_third_method(:update,_alias) do |*args|
send(_alias,*args)
update_auto_update
end
end
end
end
#==============================================================================
# ** LiTTleDRAgo
#------------------------------------------------------------------------------
#
#==============================================================================
module LiTTleDRAgo
#-------------------------------------------------------------------------
# * Constant
#-------------------------------------------------------------------------
VX = defined?(Window_ActorCommand)
VXA = defined?(Window_BattleActor)
XP = !VX
RGSS1 = defined?(Hangup)
RGSS2 = RUBY_VERSION == '1.8.1' && !RGSS1
RGSS3 = RUBY_VERSION == '1.9.2'
APPPATHDRAGO = "#{ENV['APPDATA']}/Drago/"
end
#==============================================================================
# ** CoreDLL
#------------------------------------------------------------------------------
#
#==============================================================================
module CoreDLL
#-------------------------------------------------------------------------
# * Constant
#-------------------------------------------------------------------------
DLL_USED = ['kernel32','msvcrt','user32','gdi32']
SCENEVXA = "SceneManager.send(:instance_variable_set,:@scene,args.at(0))"
L = LiTTleDRAgo
#-------------------------------------------------------------------------
# * Public Instance Variables
#-------------------------------------------------------------------------
attr_sec_reader :rtlmemory_pi, "winapi(0,'RtlMoveMemory','pii','i')"
attr_sec_reader :rtlmemory_ip, "winapi(0,'RtlMoveMemory','ipi','i')"
attr_sec_reader :setpriority, "winapi(0,'SetPriorityClass','pi','i')"
attr_sec_reader :getprocesstime,"winapi(0,'GetProcessTimes','ipppp','i')"
attr_sec_reader :getdc, "winapi(2,'GetDC','i','i')"
attr_sec_reader :releasedc, "winapi(2,'ReleaseDC','ii','i')"
attr_sec_reader :reghotkey, "winapi(2,'RegisterHotKey', 'liii', 'i')"
attr_sec_reader :sendinput, "winapi(2,'SendInput','ipi','i')"
attr_sec_reader :setwindowlong, "winapi(2,'SetWindowLong','lll','l')"
attr_sec_reader :getkeysta, "winapi(2,'GetKeyboardState','p','i')"
attr_sec_reader :getkeylay, "winapi(2,'GetKeyboardLayout','l','l')"
attr_sec_reader :mapvirkey, "winapi(2,'MapVirtualKeyEx','iil','i')"
attr_sec_reader :tounicode, "winapi(2,'ToUnicodeEx','llppill','l')"
attr_sec_reader :screentoclient,"winapi(2,'ScreenToClient', 'lp', 'i')"
attr_sec_reader :cursorposition,"winapi(2,'GetCursorPos', 'p', 'i')"
attr_sec_reader :systemmetrix, "winapi(2,'GetSystemMetrics', %w(i), 'i')"
attr_sec_reader :bitblt, "winapi(3,'BitBlt','iiiiiiiii','i')"
attr_sec_reader :ccdc, "winapi(3,'CreateCompatibleDC','i','i')"
attr_sec_reader :ccbitmap, "winapi(3,'CreateCompatibleBitmap','iii','i')"
attr_sec_reader :deleteobject, "winapi(3,'DeleteObject','i','i')"
attr_sec_reader :getbitmapbits, "winapi(3,'GetBitmapBits','llp','l')"
attr_sec_reader :getdibits, "winapi(3,'GetDIBits','iiiiipi','i')"
attr_sec_reader :setdibits, "winapi(3,'SetDIBits','iiiiipi','i')"
attr_sec_reader :selectobject, "winapi(3,'SelectObject','ii','i')"
attr_sec_reader :getpixel, "winapi(3,'GetPixel','iii','i')"
attr_sec_reader :setpixel, "winapi(3,'SetPixel','liil','l')"
attr_sec_reader :disabled_key, "Array.new"
attr_sec_reader :high_priority, 'false'
#-------------------------------------------------------------------------
# * Define Secondary Listing
#-------------------------------------------------------------------------
define_sec_method(:disable_alt_enter) { disable_keys(0x0D) }
define_sec_method(:fullscreen?) { systemmetrix.call(0) == Graphics.width }
define_sec_method(:fullscreen) { self.fullscreen? || toggle }
define_sec_method(:window) { self.fullscreen? && toggle }
#-------------------------------------------------------------------------
# * Redirect Listing
#-------------------------------------------------------------------------
redirect_method :cache, L::VX ? '(Cache)' : '(RPG::Cache)'
redirect_method :scene, L::VXA ? '(SceneManager.scene)':'($scene)'
redirect_method :scene=, L::VXA ? SCENEVXA : '($scene = args[0])'
#-------------------------------------------------------------------------
# * Enable change window size via mouse (border required)
# Screen will not resized if RMXP
#-------------------------------------------------------------------------
def control_screen_size(enable = true)
hid = @hide_border ? 0x14000000 : 0x14CA0000
set = enable ? (0x10C70000|0x00080000) : hid
self.setwindowlong.call(self.hwnd,-16, set)
end
#-------------------------------------------------------------------------
# * Hide window border
# Screen size can't be controlled via mouse
#-------------------------------------------------------------------------
def hide_borders
control_screen_size((@hide_border = true) && false)
end
#-------------------------------------------------------------------------
# * Show window border
# Screen size can't be controlled via mouse
#-------------------------------------------------------------------------
def show_borders
control_screen_size((@hide_border = false))
end
#-------------------------------------------------------------------------
# * Disable Key
#-------------------------------------------------------------------------
def disable_keys(*keys)
keys.each do |key|
disabled_key.include?(key) || disabled_key.push(key)
self.reghotkey.call(self.hwnd, 1, 0x0001, key)
end
end
#-------------------------------------------------------------------------
# * Resize the screen (scaled)
# Screen will not resized if RMXP
#-------------------------------------------------------------------------
def scale_screen(width, height)
width += ((res = self.systemmetrix).call(5) + (res.call(45))) * 2
height += (res.call(6) + (res.call(46))) * 2 + res.call(4)
x = [(res.call(0) - width) / 2, 0].max
y = [(res.call(1) - height) / 2, 0].max
self.setwindowpos(self.hwnd,0,x,y,width,height,0)
end
#-------------------------------------------------------------------------
# * Scale the game.exe to fill the monitor
# Screen will not resized if RMXP
#-------------------------------------------------------------------------
def fill_monitor
setwindowpos(hwnd,0,0,0,(res = systemmetrix).call(0),res.call(1),0)
end
#-------------------------------------------------------------------------
# * setwindowpos
#-------------------------------------------------------------------------
def setwindowpos(hwnd = self.hwnd,at = 0,x = 0,y = 0,
width = 640, height = 480, ni = 0)
@setwindowpos ||= winapi(2, 'SetWindowPos', 'liiiiip','i')
@setwindowpos.call(hwnd, at, x, y, width, height, ni)
end
#-------------------------------------------------------------------------
# * Toggle between fullscreen and windowed
#-------------------------------------------------------------------------
def toggle
@keybd ||= winapi(2, 'keybd_event', %w(i i l l), 'v')
[@keybd.call(0xA4, 0, 0, 0), @keybd.call(13, 0, 0, 0) ]
[@keybd.call(13, 0, 2, 0), @keybd.call(0xA4, 0, 2, 0)]
end
#-------------------------------------------------------------------------
# * Show FPS
#-------------------------------------------------------------------------
def show_fps
@show_fps ||= winapi(2, 'keybd_event', %w(l l l l), '')
@show_fps.call(0x71,0,0,0)
sleep(0.1)
@show_fps.call(0x71,0,2,0)
end
#-------------------------------------------------------------------------
# * Get the Game Window's width and height
#-------------------------------------------------------------------------
def client_size
@window_c_rect ||= winapi(2, 'GetClientRect', %w(l p), 'i')
@window_c_rect.call(self.hwnd, (rect = [0, 0, 0, 0].pack('l4')))
right, bottom = rect.unpack('l4')[2..3]
return right, bottom
end
#-------------------------------------------------------------------------
# * Get the game window handle (specific to game)
#-------------------------------------------------------------------------
def hwnd
@game_window ||= winapi(2, 'FindWindowEx', %w(l l p p), 'i').
call(0,0,"RGSS Player",0)
end
#-------------------------------------------------------------------------
# * always_on_top (cannot be undone)
#-------------------------------------------------------------------------
def always_on_top
res = self.systemmetrix
width = Graphics.width + (res.call(5) + (res.call(45))) * 2
height = Graphics.height + (res.call(6) + (res.call(46))) * 2 + res.call(4)
x = [(res.call(0) - width) / 2, 0].max
y = [(res.call(1) - height) / 2, 0].max
self.setwindowpos(self.hwnd,-1,x,y,width,height,0x0200)
end
#-------------------------------------------------------------------------
# * Get the value of game.ini
#-------------------------------------------------------------------------
def read_ini(field, key, ini = 'Game.ini')
@gpps ||= winapi(0, 'GetPrivateProfileString', 'pppplp', 'l')
@gpps.call(field,key,"",result="\0"*256,256,".//#{ini}") rescue return ""
return result.delete!("\0")
end
#-------------------------------------------------------------------------
# * Data default extension
#-------------------------------------------------------------------------
def data_default_extension
data = read_ini('Game','Scripts')
data = data.split('.').last || 'rxdata'
return data
end
#-------------------------------------------------------------------------
# * High Priority (true/false)
#-------------------------------------------------------------------------
def high_priority=(value)
@high_priority = value && true
setpriority.call(-1, @high_priority ? 0x00000080 : 0x00000020)
end
#--------------------------------------------------------------------------
# * snap_to_bitmap
#--------------------------------------------------------------------------
def snap_to_bitmap
bitmap = Bitmap.new((w = client_size.at(0)),(h = client_size.at(1)))
info = [40,w,h,1,32,0,0,0,0,0,0].pack('LllSSLLllLL')
hDC = ccdc.call((dc = getdc.call(hwnd)))
deleteobject.call(selectobject.call(hDC, (hBM = ccbitmap.call(dc, w, h))))
setdibits.call(hDC, hBM, 0, h, (a = bitmap.address), info, 0)
bitblt.call(hDC, 0, 0, w, h, dc, 0, 0, 0xCC0020)
getdibits.call(hDC, hBM, 0, h, a, info, 0)
deleteobject.call(hBM)
deleteobject.call(hDC)
return bitmap
end
#-------------------------------------------------------------------------
# * Execute Win32API
#-------------------------------------------------------------------------
def winapi(*a)
Win32API.new(*((a[0].is_a?(Integer) ? a[0] = DLL_USED[a[0]] : a) && a))
end
#----------------------------------------------------------------------------
# * unicode_to_utf8
# string - string in Unicode format
# Converts a string from Unicode format to UTF-8 format as RGSS does not
# support Unicode.
#----------------------------------------------------------------------------
def unicode_to_utf8(string)
result = ''
string.unpack('L*').each do |c|
if (c1 = c < 0x0080) || (c2 = c < 0x0800) || (c3 = c < 0x10000) ||
(c4 = c < 0x200000)|| (c5 = c < 0x4000000) || (c6 = c < 0x80000000)
result += c.chr if c1
result += (0xC0 | (c >> 6)).chr if c2
result += (0xE0 | (c >> 12)).chr if c3
result += (0xF0 | (c >> 18)).chr if c4
result += (0xF8 | (c >> 24)).chr if c5
result += (0xFC | (c >> 30)).chr if c6
result += (0x80 | ((c >> 24) & 0x3F)).chr if c6
result += (0x80 | ((c >> 18) & 0x3F)).chr if c5 || c6
result += (0x80 | ((c >> 12) & 0x3F)).chr if c4 || c5 || c6
result += (0x80 | ((c >> 6) & 0x3F)).chr if c3 || c4 || c5 || c6
result += (0x80 | (c & 0x3F)).chr if c2 || c3 || c4 || c5 || c6
end
end
return result
end
end
LiTTleDRAgo.extend(CoreDLL)
#==============================================================================
# ** RPG
#------------------------------------------------------------------------------
#
#==============================================================================
module RPG
#============================================================================
# ** System
#----------------------------------------------------------------------------
#
#============================================================================
class System
#----------------------------------------------------------------------
# ● Class Variables
#----------------------------------------------------------------------
if (VX = LiTTleDRAgo::VX)
#------------------------------------------------------------------------
# ● Public Instance Variables
#------------------------------------------------------------------------
attr_accessor :magic_number, :windowskin_name, :gameover_name
attr_accessor :battle_transition, :battleback_name, :title_name
#------------------------------------------------------------------------
# ● Redefined Methods
#------------------------------------------------------------------------
redirect_method :sounds, "$data_system.sounds"
redirect_method :cursor_se, "sounds[0]"
redirect_method :decision_se, "sounds[1]"
redirect_method :cancel_se, "sounds[2]"
redirect_method :buzzer_se, "sounds[3]"
redirect_method :equip_se, "sounds[4]"
redirect_method :save_se, "sounds[5]"
redirect_method :load_se, "sounds[6]"
redirect_method :battle_start_se, "sounds[7]"
redirect_method :escape_se, "sounds[8]"
if (VXA = LiTTleDRAgo::VXA)
redirect_method :shop_se, "sounds[21]"
redirect_method :actor_collapse_se, "sounds[15]"
else
redirect_method :shop_se, "sounds[17]"
redirect_method :actor_collapse_se, "sounds[13]"
end
redirect_method :enemy_collapse_se, "sounds[11]"
redirect_method :words, "@words ||= RPG::System::Words.new()"
#------------------------------------------------------------------------
# ● Aliased Methods
#------------------------------------------------------------------------
alias_sec_method :battleback_name, :battleback1_name
alias_sec_method :title_name, :title1_name
end
#========================================================================
# ** Words
#------------------------------------------------------------------------
#
#========================================================================
class Words
#----------------------------------------------------------------------
# ● New Methods
#----------------------------------------------------------------------
attr_sec_accessor :params, !(VXA = LiTTleDRAgo::VXA) ? !VX ?
'[hp,sp,str,dex,agi,int]' : # XP
'[hp,sp,atk,pdef,int,agi]' : # VX
'[hp,sp,atk,pdef,int,mdef,agi,luk]' # VXA
attr_sec_accessor :weapon1, VX && !VXA ? 'Vocab.weapon1' : "'Weapon 1'"
attr_sec_accessor :weapon2, VX && !VXA ? 'Vocab.weapon2' : "'Weapon 2'"
attr_sec_accessor :status, VX ? 'Vocab.status' : "'Status' "
attr_sec_accessor :save, VX ? 'Vocab.save' : "'Save' "
attr_sec_accessor :game_end, VX ? 'Vocab.game_end' : "'Game End'"
attr_sec_accessor :fight, VX ? 'Vocab.fight' : "'Fight' "
attr_sec_accessor :escape, VX ? 'Vocab.escape' : "'Escape' "
attr_sec_accessor :new_game, VX ? 'Vocab.new_game' : "'New Game'"
attr_sec_accessor :continue, VX ? 'Vocab.continue' : "'Continue'"
attr_sec_accessor :shutdown, VX ? 'Vocab.shutdown' : "'Shutdown'"
attr_sec_accessor :to_title, VX ? 'Vocab.to_title' : "'To Title'"
attr_sec_accessor :cancel, VX ? 'Vocab.cancel' : "'Cancel' "
#----------------------------------------------------------------------
# ● Redirect Listings
#----------------------------------------------------------------------
redirect_method :gold, (VXA ? 'Vocab.currency_unit' : 'Vocab.gold')
redirect_method :hp, 'Vocab.hp'
redirect_method :sp, 'Vocab.mp'
redirect_method :str, 'String.new()'
redirect_method :dex, 'String.new()'
redirect_method :luk, (VXA ? 'Vocab.param(7)' : 'String.new()')
redirect_method :agi, (VXA ? 'Vocab.param(6)' : 'Vocab.agi')
redirect_method :int, (VXA ? 'Vocab.param(4)' : 'Vocab.spi')
redirect_method :atk, (VXA ? 'Vocab.param(2)' : 'Vocab.atk')
redirect_method :pdef, (VXA ? 'Vocab.param(3)' : 'Vocab.def')
redirect_method :mdef, (VXA ? 'Vocab.param(5)' : 'String.new()')
redirect_method :weapon, (VXA ? 'Vocab.etype(0)' : 'Vocab.weapon')
redirect_method :armor1, (VXA ? 'Vocab.etype(1)' : 'Vocab.armor1')
redirect_method :armor2, (VXA ? 'Vocab.etype(2)' : 'Vocab.armor2')
redirect_method :armor3, (VXA ? 'Vocab.etype(3)' : 'Vocab.armor3')
redirect_method :armor4, (VXA ? 'Vocab.etype(4)' : 'Vocab.armor4')
redirect_method :attack, 'Vocab.attack'
redirect_method :skill, 'Vocab.skill'
redirect_method :guard, 'Vocab.guard'
redirect_method :item, 'Vocab.item'
redirect_method :equip, 'Vocab.equip'
end
end
end
#==============================================================================
# ** RPG_FileTest
#------------------------------------------------------------------------------
#
#==============================================================================
module RPG_FileTest
#--------------------------------------------------------------------------
# ● New method: self.exist?
#--------------------------------------------------------------------------
def self.exist?(filename)
dir,ext = File.dirname(filename) + '/', File.extname(filename)
base = File.basename(filename, ext)
if ['.png','.jpg','.bmp'].include?(ext.downcase)
cache = defined?(Cache) ? Cache : RPG::Cache
(cache.load_bitmap(dir,base) && true) rescue false
elsif ['.rxdata','.rvdata','.rvdata2','.rb','.txt'].include?(ext.downcase)
(load_data(filename) && true) rescue false
else
File.exist?(filename)
end
end
end
#==============================================================================
# ** Sound
#------------------------------------------------------------------------------
# This module plays sound effects. It obtains sound effects specified in the
# database from the global variable $data_system, and plays them.
#==============================================================================
module Sound; end
class << Sound
#------------------------------------------------------------------------
# ● New Method :se_play
#------------------------------------------------------------------------
unless method_defined?(:se_play)
def se_play(type)
system = ($game_system ||= Game_System.new)
case type
when :cursor then system.se_play($data_system.cursor_se)
when :decision then system.se_play($data_system.decision_se)
when :cancel then system.se_play($data_system.cancel_se)
when :buzzer then system.se_play($data_system.buzzer_se)
when :shop then system.se_play($data_system.shop_se)
when :equip then system.se_play($data_system.equip_se)
when :save then system.se_play($data_system.save_se)
when :load then system.se_play($data_system.load_se)
when :battle_start then system.se_play($data_system.battle_start_se)
when :escape then system.se_play($data_system.escape_se)
when :actor_collapse then system.se_play($data_system.actor_collapse_se)
when :enemy_collapse then system.se_play($data_system.enemy_collapse_se)
end
end
end
#--------------------------------------------------------------------------
# * Redefined Method
#--------------------------------------------------------------------------
define_sec_method(:play_cursor) { se_play(:cursor) }
define_sec_method(:play_decision) { se_play(:decision) }
define_sec_method(:play_cancel) { se_play(:cancel) }
define_sec_method(:play_buzzer) { se_play(:buzzer) }
define_sec_method(:play_equip) { se_play(:equip) }
define_sec_method(:play_save) { se_play(:save) }
define_sec_method(:play_load) { se_play(:load) }
define_sec_method(:play_battle_start) { se_play(:battle_start) }
define_sec_method(:play_escape) { se_play(:escape) }
define_sec_method(:play_enemy_collapse) { se_play(:enemy_collapse) }
define_sec_method(:play_actor_collapse) { se_play(:actor_collapse) }
define_sec_method(:play_shop) { se_play(:shop) }
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias_sec_method :play_ok, :play_decision
end
#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
# This class handles data surrounding the system. Backround music, etc.
# is managed here as well. Refer to "$game_system" for the instance of
# this class.
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# * Constant
#--------------------------------------------------------------------------
VX = LiTTleDRAgo::VX && !LiTTleDRAgo::VXA
#--------------------------------------------------------------------------
# * Public Instance Variable
#--------------------------------------------------------------------------
attr_sec_accessor :bgm_volume , 100
attr_sec_accessor :bgs_volume , 100
attr_sec_accessor :me_volume , 100
attr_sec_accessor :se_volume , 100
attr_sec_accessor :bgm_pitch , 100
attr_sec_accessor :bgs_pitch , 100
attr_sec_accessor :me_pitch , 100
attr_sec_accessor :se_pitch , 100
attr_sec_accessor :volume_control, 'false'
#--------------------------------------------------------------------------
# * Redefined method: bgm_memorize, bgm_restore
#--------------------------------------------------------------------------
VX && define_sec_method(:bgm_memorize) { @memorized_bgm = @playing_bgm }
VX && define_sec_method(:bgm_restore) { bgm_play(@memorized_bgm) }
#--------------------------------------------------------------------------
# * Redirect Listing
#--------------------------------------------------------------------------
redirect_method :bgm_stop, 'Audio.bgm_stop'
redirect_method :bgs_stop, 'Audio.bgs_stop'
redirect_method :se_stop, 'Audio.se_stop'
redirect_method :me_stop, 'Audio.me_stop'
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias_sec_method :bgm_memorize, :save_bgm
alias_sec_method :bgm_restore, :replay_bgm
alias_sec_method :save_bgm, :bgm_memorize
alias_sec_method :replay_bgm, :bgm_restore
#--------------------------------------------------------------------------
# * Aliased method: bgm_play, bgs_play, me_play, se_play
#--------------------------------------------------------------------------
[:bgm,:bgs,:me,:se].each do |sa|
next unless method_defined?(:"#{sa}_play")
alias_sec_method(:"drg_#{sa}_play", :"#{sa}_play")
define_method(:"#{sa}_play") do |bgm,*a|
if bgm.is_a?(String) && bgm != ''
bgm = RPG::AudioFile.new(bgm,send(:"#{sa}_volume"),send(:"#{sa}_pitch"))
elsif volume_control && bgm.is_a?(RPG::AudioFile) && bgm.name != ""
bgm = bgm.clone
bgm.volume = Math.percent(bgm.volume,send(:"#{sa}_volume"))
bgm.pitch = Math.percent(bgm.pitch,send(:"#{sa}_pitch"))
end
@playing_bgm = bgm if "#{sa}" == 'bgm'
@playing_bgs = bgm if "#{sa}" == 'bgs'
if respond_to?(:"drg_#{sa}_play")
send(:"drg_#{sa}_play", bgm,*a)
else
if bgm.is_a?(RPG::AudioFile) && bgm.name != ''
Audio.send(:"#{sa}_play","Audio/#{sa}/" + bgm.name,
bgm.volume.round, bgm.pitch.round,*a)
else
send(:"#{sa}_stop")
end
Graphics.frame_reset
end
end
end
end
#==============================================================================
# ** Object
#------------------------------------------------------------------------------
# This class is superclass for all class
#==============================================================================
class Object
#-------------------------------------------------------------------------
# * New method: all_variable_dispose
#-------------------------------------------------------------------------
def all_variable_dispose
all = instance_variables.map {|s| instance_variable_get("#{s}")}.flatten
all.delete_if {|s| s.not.respond_to?(:dispose) }
all.delete_if {|s| s.respond_to?(:disposed?) && s.disposed?}
all.dispose
end
#-------------------------------------------------------------------------
# * New method: rand_between
#-------------------------------------------------------------------------
unless method_defined?(:rand_between)
def rand_between(min, max)
min + rand(max - min + 1) if min.is_a?(Numeric) && max.is_a?(Numeric)
end
end
#-------------------------------------------------------------------------
# * New method: get_note
#-------------------------------------------------------------------------
unless method_defined?(:get_note)
def get_note
respond_to?(:note) ? note : ""
end
end
#-------------------------------------------------------------------------
# * New method: screen_rect
#-------------------------------------------------------------------------
unless method_defined?(:screen_rect)
def screen_rect(as_rect = true)
array = [0,0,Graphics.width,Graphics.height]
as_rect ? Rect.new(*array) : array
end
end
#-------------------------------------------------------------------------
# * New method: forcesave
#-------------------------------------------------------------------------
unless method_defined?(:forcesave)
def forcesave(index)
return DataManager.save_game(index) if defined?(DataManager)
save = LiTTleDRAgo::VX ? Scene_File.new(0,nil,0) : Scene_Save.new
begin
file = File.open(save.make_filename(index), "wb")
(save.write_save_data(file) && file.close) || true
rescue
File.delete(save.make_filename(index)) rescue nil
(Sound.play_buzzer) && false
end
end
end
#--------------------------------------------------------------------------
# * sprite_report
#--------------------------------------------------------------------------
unless method_defined?(:script_report)
def script_report(text,font = nil)
s = (text.is_a?(String) || (text = text.inspect)) && Sprite.new
s.opacity = (s.bitmap = Bitmap.new((g = Graphics).width,g.height)) && 0
s.bitmap.font.name = ['Georgia',Font.default_name].flatten
s.bitmap.font = (s.z += 9999) && (font || s.bitmap.font)
y = (text.split(/\n/).size * s.bitmap.text_size(text).height) / 2
s.bitmap.draw_enter_edging_text(0,0-y,g.width,g.height,text,1)
(s.opacity += 10) && g.update until s.opacity >= 255
g.wait_for_input
(s.opacity -= 10) && g.update until s.opacity <= 0
s.dispose
end
end
#-------------------------------------------------------------------------
# * New method: not
#-------------------------------------------------------------------------
define_sec_method(:not) { Not.new(self) }
#============================================================================
# ** Not
#----------------------------------------------------------------------------
#
#============================================================================
class Not
#-------------------------------------------------------------------------
# * Private
#-------------------------------------------------------------------------
private *instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ }
#-------------------------------------------------------------------------
# * Object Initialization
#-------------------------------------------------------------------------
define_method(:initialize) {|original| @original = original }
#-------------------------------------------------------------------------
# * New method: method_missing
#-------------------------------------------------------------------------
def method_missing(sym, *a, &blk)
!@original.send(sym, *a, &blk)
end
end
end
#==============================================================================
# ** Kernel
#------------------------------------------------------------------------------
#
#==============================================================================
module Kernel
#-------------------------------------------------------------------------
# * Alias Listing
#-------------------------------------------------------------------------
$@ || alias_method(:carrot, :proc)
#-------------------------------------------------------------------------
# * Script Check
#-------------------------------------------------------------------------
if LiTTleDRAgo::XP && LiTTleDRAgo::RGSS3 && !defined?(XPA_CONFIG)
$@ || alias_method(:last_before_p, :p)
$@ || alias_method(:last_before_print, :print)
$@ || alias_method(:last_before_msgbox, :msgbox)
$@ || alias_method(:last_before_msgbox_p, :msgbox_p)
define_method(:p) {|*args| last_before_msgbox_p(*args)}
define_method(:print) {|*args| last_before_msgbox(*args) }
define_method(:msgbox) {|*args| last_before_print(*args) }
define_method(:msgbox_p){|*args| last_before_p(*args) }
end
define_method(:draise) {|*args| (dp(*args) && !1) || exit }
define_method(:dp) {|*a| script_report(a.map {|i| i.inspect}.join("\n"))}
#-------------------------------------------------------------------------
# * New method: dprint
#-------------------------------------------------------------------------
def dprint(*args)
script_report(args.map {|i| i.is_a?(String) ? i : i.inspect}.join)
end
#-------------------------------------------------------------------------
# * New method: press_any_key
#-------------------------------------------------------------------------
unless method_defined?(:press_any_key)
def press_any_key
return false if Input.nil?
return true if Input.trigger?(Input::A) ||Input.trigger?(Input::B)
return true if Input.trigger?(Input::C) ||Input.trigger?(Input::X)
return true if Input.trigger?(Input::Y) ||Input.trigger?(Input::Z)
return true if Input.trigger?(Input::L) ||Input.trigger?(Input::R)
return true if Input.trigger?(Input::UP) ||Input.trigger?(Input::DOWN)
return true if Input.trigger?(Input::LEFT) ||Input.trigger?(Input::RIGHT)
return true if Input.trigger?(Input::SHIFT)||Input.trigger?(Input::CTRL)
return true if Input.trigger?(Input::ALT) ||Input.trigger?(Input::F5)
return true if Input.trigger?(Input::F6) ||Input.trigger?(Input::F7)
return true if Input.trigger?(Input::F8) ||Input.trigger?(Input::F9)
end
end
#-------------------------------------------------------------------------
# * New method: inspect_instance_variable
#-------------------------------------------------------------------------
unless method_defined?(:inspect_instance_variable)
def inspect_instance_variable(class_name, variable)
Module.const_get(class_name).new.instance_variable_get(:"@#{variable}")
end
end
end
#==============================================================================
# ** Proc
#------------------------------------------------------------------------------
#
#==============================================================================
class Proc
#-------------------------------------------------------------------------
# * New method: bind
#-------------------------------------------------------------------------
unless method_defined?(:bind)
def bind(object)
block, time = self, Time.now
class << object
self
end.class_eval do
define_method((name = "__bind_#{time.to_i}_#{time.usec}"), &block)
remove_method((method = instance_method(name)) && name)
method
end.bind(object)
end
end
end
#==============================================================================
# ** Enumerable
#------------------------------------------------------------------------------
#
#==============================================================================
module Enumerable
#---------------------------------------------------------------------------
# * Redefined method: shuffle
#---------------------------------------------------------------------------
define_sec_method(:shuffle) {(a = entries) && Array.new(size){ a.random!}}
#---------------------------------------------------------------------------
# * New method: random_each
#---------------------------------------------------------------------------
unless method_defined?(:random_each)
def random_each() (block_given? ? shuffle.each {|s| yield s } : random) end
end
#---------------------------------------------------------------------------
# * New method: random_each_with_index
#---------------------------------------------------------------------------
unless method_defined?(:random_each_with_index)
def random_each_with_index
block_given? ? self.shuffle.each_with_index {|obj, i| yield obj,i } :
self.random
end
end
#---------------------------------------------------------------------------
# * Redefined method: drop_while
#---------------------------------------------------------------------------
unless method_defined?(:drop_while)
def drop_while(&block)
ary, state = [], false
self.each do |e|
state = true if !state and !block.call(e)
ary << e if state
end
ary
end
end
#---------------------------------------------------------------------------
# * Redefined method: take_while
#---------------------------------------------------------------------------
unless method_defined?(:take_while)
def take_while(&block)
ary = []
self.each do |e|
return ary unless block.call(e)
ary << e
end
ary
end
end
#---------------------------------------------------------------------------
# * Redefined method: partition
#---------------------------------------------------------------------------
unless method_defined?(:partition)
def partition(&block)
ary_T, ary_F = [], []
self.each {|val| block.call(val) ? ary_T.push(val) : ary_F.push(val)}
return ary_T, ary_F
end
end
#---------------------------------------------------------------------------
# * Redefined method: grep
#---------------------------------------------------------------------------
unless method_defined?(:grep)
def grep(pattern, &block)
collect {|v| pattern === v && ary.push((block)? block.call(v): v)}
end
end
#---------------------------------------------------------------------------
# * Redefined method: each_slice
#---------------------------------------------------------------------------
unless method_defined?(:each_slice)
def each_slice(n, &block)
not_integer = "expected Integer for 1st argument"
n.is_a?(Integer) || raise(TypeError,not_integer,caller(1))
n <= 0 && raise(ArgumentError, "invalid slice size",caller(1))
ary = []
self.each do |e|
ary << e
if ary.size == n
block.call(ary)
ary = []
end
end
block.call(ary) unless ary.empty?
end
end
#---------------------------------------------------------------------------
# * Redefined method: minmax
#---------------------------------------------------------------------------
unless method_defined?(:minmax)
def minmax(&block) (a = sort(&block)) && [a.first,a.last] end
end
end
#==============================================================================
# ** Array
#------------------------------------------------------------------------------
#
#==============================================================================
class Array
#---------------------------------------------------------------------------
# * Define Secondary Listing
#---------------------------------------------------------------------------
define_sec_method(:have_all?) { |*array| self & array == array }
define_sec_method(:have_any?) { |*array| self - array != self }
define_sec_method(:relay) { |type| map {|s| s.send(:"to_#{type}")}}
#---------------------------------------------------------------------------
# * Redirect method
#---------------------------------------------------------------------------
redirect_method :switch_on, 'self.switch = (true)'
redirect_method :switch_off, 'self.switch = (false)'
redirect_method :random, 'self.at(rand(size))'
redirect_method :random!, 'self.delete_at(rand(size))'
redirect_method :sum, 'self.inject(0) {|r, n| r += n}'
redirect_method :prod, 'self.inject(1) {|r, n| r *= n}'
redirect_method :next_item, '(item = shift) && push(item) && (item)'
redirect_method :previous_item, '(item = pop) && unshift(item) && (item)'
redirect_method :nitems, 'count {|x| x.not.nil?}'
redirect_method :switch_reverse, 'switch=(:flip)'
#---------------------------------------------------------------------------
# * New method: method_missing
#---------------------------------------------------------------------------
def method_missing(val,*a,&b)
en = self.entries.find_all {|s|s.respond_to?(val.to_sym)}
if self.not.empty? && en.empty?
text = "Undefined method #{val} for #{self.inspect}"
raise(NoMethodError,text,caller(1))
end
return en.map {|s| s.send(val.to_s,*a,&b)}
end
#-------------------------------------------------------------------------
# * New method: each_ntuple
#-------------------------------------------------------------------------
unless method_defined?(:each_ntuple)
def each_ntuple(number)
0.step(size - size % number - 1, number) {|i| yield(*self[i, number])}
end
end
#-------------------------------------------------------------------------
# * New method: each_pair
#-------------------------------------------------------------------------
unless method_defined?(:each_pair)
def each_pair() each_ntuple(2) {|a,b| yield a, b } end
end
#---------------------------------------------------------------------------
# * New method: each_triple
#---------------------------------------------------------------------------
unless method_defined?(:each_triple)
def each_triple() each_ntuple(3) {|a,b,c| yield a, b, c } end
end
#---------------------------------------------------------------------------
# * Redefined method: shuffle! (for RMXP)
#---------------------------------------------------------------------------
unless method_defined?(:shuffle!)
def shuffle!() self.dup == replace(shuffle) ? nil : self end
end
#---------------------------------------------------------------------------
# * New method: sort_by!
#---------------------------------------------------------------------------
unless method_defined?(:sort_by!)
def sort_by!(*args,&block)
self.dup == replace(sort_by(*args,&block)) ? nil : self
end
end
#---------------------------------------------------------------------------
# * New method: recursive_clone
#---------------------------------------------------------------------------
unless method_defined?(:rclone)
def recursive_clone
(clon = self.clone).each_index do |i|
clon[i] = clon[i].recursive_clone rescue clon[i].clone rescue clon[i]
end
clon
end
alias_method(:rclone, :recursive_clone)
end
#---------------------------------------------------------------------------
# * New method: to_hash
#---------------------------------------------------------------------------
unless method_defined?(:to_hash)
def to_hash
(hash = Hash.new) && each_index {|i| hash[i] = self[i]} && hash
end
end
#---------------------------------------------------------------------------
# * Redefined method: count
#---------------------------------------------------------------------------
unless method_defined?(:count)
def count(*args, &block)
if block_given?
find_all {|s| block.call(s)}.size
else
ary = args.empty? ? self : args.map {|a| find_all{|s| s == a}}
ary.compact.size
end
end
end
#---------------------------------------------------------------------------
# * New method: each_with_next
#---------------------------------------------------------------------------
unless method_defined?(:each_with_next)
def each_with_next(num = 1)
(size - num).times {|i| yield(*self[i..(i+num)])}
end
end
#---------------------------------------------------------------------------
# * New method: switch=
#---------------------------------------------------------------------------
unless method_defined?(:switch=)
def switch=(value)
integer = search_var_key[0]
array = search_var_key[1]
if value == :flip
integer.each {|i| $game_switches[i] = !$game_switches[i] }
array.each {|i| $game_self_switches[i] = !$game_self_switches[i] }
else
integer.each {|i| $game_switches[i] = value }
array.each {|i| $game_self_switches[i] = value }
end
$game_map.need_refresh = true if $game_map.respond_to?(:need_refresh)
end
end
#---------------------------------------------------------------------------
# * New method: variable
#---------------------------------------------------------------------------
def variable(value = nil,method = "=")
integer = search_var_key[0]
integer += search_var_key[1] if $drago_game_variable
return integer.map {|i| $game_variables[i]} if value.nil?
result = integer.map {|i| eval("$game_variables[i] #{method} #{value}") }
$game_map.need_refresh = true if $game_map.respond_to?(:need_refresh)
result
end
#---------------------------------------------------------------------------
# * New method: search_var_key
#---------------------------------------------------------------------------
def search_var_key
integer = self.find_all {|s| s.is_a?(Integer)}
range = self.find_all {|s| s.is_a?(Range) }
array = self.find_all {|s| s.is_a?(Array) }
string = self.find_all {|s| s.is_a?(String) }
integer = integer + range.collect {|s| s.to_a }.flatten
$game_switches ||= Game_Switches.new
$game_self_switches ||= Game_SelfSwitches.new
$game_variables ||= Game_Variables.new
return [integer.sort.uniq, array.sort.uniq]
end
#---------------------------------------------------------------------------
# * New method: rindexes
#---------------------------------------------------------------------------
unless method_defined?(:rindexes)
def rindexes(*values)
array = Array.new
each_index {|i| values.include?(self[i]) && array.push(i)}
array
end
end
#---------------------------------------------------------------------------
# * New method: deep
#---------------------------------------------------------------------------
unless method_defined?(:deep)
def deep(deep = -1)
tmp_deep = deep + 1
deep = tmp_deep
self.each do |i|
deep < i.deep(tmp_deep) && deep = i.deep(tmp_deep) rescue nil
end
deep
end
end
#---------------------------------------------------------------------------
# * New method: recursive_flatten
#---------------------------------------------------------------------------
unless method_defined?(:rflatten)
def recursive_flatten
(array = self.recursive_clone).each_index do |i|
array[i] = array[i].to_a if array[i].is_a?(Hash)
array[i] = array[i].recursive_flatten rescue array[i]
end
array.flatten!
array
end
alias_method(:rflatten, :recursive_flatten)
end
#---------------------------------------------------------------------------
# * New method: recursive_flatten!
#---------------------------------------------------------------------------
unless method_defined?(:rflatten!)
def recursive_flatten!
self.each_index do |i|
self[i] = self[i].to_a if self[i].is_a?(Hash)
self[i] = self[i].recursive_flatten! rescue self[i]
end
self.flatten!
self
end
alias_method(:rflatten!, :recursive_flatten!)
end
#---------------------------------------------------------------------------
# * Redefined method: product
#---------------------------------------------------------------------------
def dproduct(*arrays)
(e = "(result = []) && self.each {|i0| ") &&
(a = arrays.size).times {|i| e += "arrays[#{i}].each {|i#{i+1}| " }
(e += "result.push([i0,") && a.times {|i| e += "i#{i+1}," }
(e += "])}" + "}" * a + " && result" )
return eval(e)
end
alias_sec_method(:product, :dproduct)
#---------------------------------------------------------------------------
# * New method: geometric_average
#---------------------------------------------------------------------------
unless method_defined?(:geometric_average)
def geometric_average(float = false)
average = empty? ? 0 : prod ** (1.0 / size)
return (float ? average : average.to_i)
end
end
#---------------------------------------------------------------------------
# * New method: average
#---------------------------------------------------------------------------
unless method_defined?(:average)
def average(float = false)
sum / [(float ? size.to_f : size.to_i), 1].max
end
end
#---------------------------------------------------------------------------
# * Alias method
#---------------------------------------------------------------------------
alias_sec_method :has_all?, :have_all?
alias_sec_method :has_any?, :have_any?
end
#==============================================================================
# ** Hash
#------------------------------------------------------------------------------
#
#==============================================================================
class Hash
#--------------------------------------------------------------------------
# * Define Secondary Listing
#--------------------------------------------------------------------------
define_sec_method(:reverse!) { self.dup == replace(reverse) ? nil : self }
#--------------------------------------------------------------------------
# ● New method: reverse
#--------------------------------------------------------------------------
unless method_defined?(:reverse)
def reverse
key, new_hash = self.keys, {}
key.reverse.each_with_index {|k,i| new_hash[k] = self[key[i]]}
new_hash
end
end
#--------------------------------------------------------------------------
# ● New method: recursive_clone
#--------------------------------------------------------------------------
unless method_defined?(:rclone)
def recursive_clone
(clon = self.clone).each_key do |i|
clon[i] = clon[i].recursive_clone rescue clon[i].clone rescue clon[i]
end
clon
end
alias_method(:rclone, :recursive_clone)
end
#--------------------------------------------------------------------------
# ● New method: deep
#--------------------------------------------------------------------------
unless method_defined?(:deep)
def deep(deep = -1)
key_deep = value_deep = tmp_deep = deep + 1
self.each do |k, v|
key_deep = k.deep(tmp_deep) if key_deep < k.deep(tmp_deep) rescue nil
value_deep = v.deep(tmp_deep)if value_deep< v.deep(tmp_deep) rescue nil
end
key_deep > value_deep ? key_deep : value_deep
end
end
#--------------------------------------------------------------------------
# ● New method: fusion
#--------------------------------------------------------------------------
unless method_defined?(:fusion)
def fusion
(array = sort).each_index do |i|
array[i] = array[i][0] + array[i][1] rescue array[i]
end
array
end
end
end
#==============================================================================
# ** Range
#------------------------------------------------------------------------------
#
#==============================================================================
class Range
#--------------------------------------------------------------------------
# * Include Comparable
#--------------------------------------------------------------------------
include(Comparable)
#-------------------------------------------------------------------------
# ● New method: random
#-------------------------------------------------------------------------
define_sec_method(:random) { self.to_a.random }
define_sec_method(:sum) { self.to_a.sum }
define_sec_method(:prod) { self.to_a.prod }
#-------------------------------------------------------------------------
# ● New method: <=>
#-------------------------------------------------------------------------
unless method_defined?(:"<=>")
def <=>(other)
temp = first <=> other.first
temp = last <=> other.last if temp = 0
return temp
end
end
end
#==============================================================================
# ** NilClass
#------------------------------------------------------------------------------
#
#==============================================================================
class NilClass
#--------------------------------------------------------------------------
# ● Overwriten method: clone, dup
#--------------------------------------------------------------------------
define_method(:clone) {|*a|}
define_method(:dup) {|*a|}
end
#==============================================================================
# ** Math
#------------------------------------------------------------------------------
#
#==============================================================================
module Math
#--------------------------------------------------------------------------
# ● New method: A (Ackermann function)
#--------------------------------------------------------------------------
def self.A(m,n)
text = 'Ackermann: No negative values allowed.' if m < 0 or n < 0
raise(ArgumentError.new(text)) if m < 0 or n < 0
return n + 1 if m == 0
return Math.A(m - 1, 1) if n == 0
return Math.A(m - 1, Math.A(m, n - 1))
end
#--------------------------------------------------------------------------
# ● New method: percent
#--------------------------------------------------------------------------
def self.percent(min,max=100)
(min / max.to_f) * 100.0
end
end
#==============================================================================
# ** Numeric
#------------------------------------------------------------------------------
#
#==============================================================================
class Numeric
#--------------------------------------------------------------------------
# ● Define Secondary Listing: clamp, sign
#--------------------------------------------------------------------------
define_sec_method(:clamp) {|min,max| [[self, min].max, max].min}
define_sec_method(:sign) { zero? ? 0 : (self / self.abs).to_i }
#--------------------------------------------------------------------------
# ● New method: group
#--------------------------------------------------------------------------
unless method_defined?(:group)
def group
self.to_s.gsub(/(\d)(?=\d{3}+(?:\.|$))(\d{3}\..*)?/,'\1,\2')
end
end
end
#==============================================================================
# ** Integer
#------------------------------------------------------------------------------
#
#==============================================================================
class Integer
#--------------------------------------------------------------------------
# ● Define Secondary Listing: sum_to, factorial
#--------------------------------------------------------------------------
define_sec_method(:sum_down) { sum_to(0)}
define_sec_method(:factorial) {(sign * (1..(self.abs)).prod) }
#--------------------------------------------------------------------------
# * New method: sum_to
#--------------------------------------------------------------------------
unless method_defined?(:sum_to)
def sum_to(v = self) (v > self ? (self..v) : (v..self)).sum end
end
end
#==============================================================================
# ** Float
#------------------------------------------------------------------------------
#
#==============================================================================
class Float
#--------------------------------------------------------------------------
# ● Overwriten method: =~
#--------------------------------------------------------------------------
# A close float comparison. Because of rounding errors, this comparison will
# help compensate for that. Since 0 and 0.0001 are very close to each other,
# it's best to use this custom comparison.
define_method(:"=~") {|num| (self + 0.0001 >= num && self - 0.0001 <= num) }
#--------------------------------------------------------------------------
# ● New method: float_points
#--------------------------------------------------------------------------
unless method_defined?(:float_points)
def float_points(points = 2)
n = self * 10 ** points
n = n.round.to_f / (10.0 ** points)
return n
end
end
end
#==============================================================================
# ** Color
#------------------------------------------------------------------------------
#
#==============================================================================
class Color
#--------------------------------------------------------------------------
# ● Define Secondary Listing
#--------------------------------------------------------------------------
define_sec_method(:invert) { set(255-red, 255-green, 255-blue, alpha)}
#----------------------------------------------------------------------------
# * New method: to_hex
#----------------------------------------------------------------------------
def to_hex
str = [self.blue.to_i, self.green.to_i, self.red.to_i].pack("C*")
str.inspect.gsub('\\x','')
end
end
class << Color
#--------------------------------------------------------------------------
# ● Define Secondary Listing: red, green, blue, white, black... etc
#--------------------------------------------------------------------------
define_sec_method(:red) {|*a| self.new(255, 0, 0,a.first||255)}
define_sec_method(:green) {|*a| self.new( 0,255, 0,a.first||255)}
define_sec_method(:blue) {|*a| self.new( 0, 0,255,a.first||255)}
define_sec_method(:white) {|*a| self.new(255,255,255,a.first||255)}
define_sec_method(:purple) {|*a| self.new(128, 0,128,a.first||255)}
define_sec_method(:gray) {|*a| self.new(128,128,128,a.first||255)}
define_sec_method(:lgray) {|*a| self.new(211,211,211,a.first||255)}
define_sec_method(:dgray) {|*a| self.new( 64, 64, 64,a.first||255)}
define_sec_method(:pink) {|*a| self.new(255,175,175,a.first||255)}
define_sec_method(:orange) {|*a| self.new(255,165, 0,a.first||255)}
define_sec_method(:brown) {|*a| self.new(128, 64, 0,a.first||255)}
define_sec_method(:chocolate){|*a| self.new(210,105, 30,a.first||255)}
define_sec_method(:golden) {|*a| self.new(218,165, 32,a.first||255)}
define_sec_method(:silver) {|*a| self.new(192,192,192,a.first||255)}
define_sec_method(:system) {|*a| self.new(192,224,255,a.first||255)}
define_sec_method(:crisis) {|*a| self.new(255,255, 64,a.first||255)}
define_sec_method(:knockout) {|*a| self.new(255, 64, 0,a.first||255)}
#--------------------------------------------------------------------------
# ● Redirect Listing: cyan, magenta, yellow, black, disabled, erase
#--------------------------------------------------------------------------
redirect_method :cyan, '(red(*args).invert )'
redirect_method :magenta, '(green(*args).invert)'
redirect_method :yellow, '(blue(*args).invert )'
redirect_method :black, '(white(*args).invert)'
redirect_method :disabled, '(black(128).invert )'
redirect_method :erase, '(white(0).invert )'
#--------------------------------------------------------------------------
# ● Alias method: grey, light_grey, dark_grey
#--------------------------------------------------------------------------
alias_sec_method :normal, :white
alias_sec_method :grey, :gray
alias_sec_method :lightgrey, :lightgray, :light_grey, :light_gray, :lgray
alias_sec_method :darkgrey, :darkgray, :dark_grey, :dark_gray, :dgray
#--------------------------------------------------------------------------
# ● New method: method_missing
#--------------------------------------------------------------------------
def method_missing(val,*a)
val = "#{val}".gsub(/x/i,'')
if "#{val}".size == 6 && "#{val}".gsub(/(\d+|[a-f])/i,'')
r = "#{val}"[0..1].hex
g = "#{val}"[2..3].hex
b = "#{val}"[4..5].hex
return self.new(r,g,b,a.first||255)
end
text = "Undefined method #{val} for #{self.inspect}"
raise(NoMethodError, text, caller(1))
end
end
#==============================================================================
# ** Viewport
#------------------------------------------------------------------------------
#
#==============================================================================
class Viewport
unless method_defined?(:disposed?)
#--------------------------------------------------------------------------
# ● Alias Listing
#--------------------------------------------------------------------------
alias_sec_method :d3x40932s2, :dispose
#--------------------------------------------------------------------------
# ● New method: disposed?
# help file is lying when says Viewport#disposed? is exist
#--------------------------------------------------------------------------
define_method(:disposed?) { @disposed == true }
#--------------------------------------------------------------------------
# ● Aliased method: dispose
#--------------------------------------------------------------------------
def dispose(*a)
(disposed? || d3x40932s2(*a) || 0) && @disposed = true
end
end
#--------------------------------------------------------------------------
# ● New method: resize
#--------------------------------------------------------------------------
define_sec_method(:resize) do |*a|
self.rect = a.first.is_a?(Rect) ? a.first : Rect.new(*a)
end
#--------------------------------------------------------------------------
# * New method: update_viewport_sizes
#--------------------------------------------------------------------------
define_sec_method(:update_viewport_sizes) do |*a|
map = $game_map
w, h = Graphics.width, Graphics.height
hor = map.respond_to?(:loop_horizontal?) && map.loop_horizontal?
ver = map.respond_to?(:loop_vertical?) && map.loop_vertical?
dx = w > map.width * 32 && !hor ? (w - map.width * 32) / 2 : 0
dw = hor ? w : [w, map.width * 32].min
dy = h > map.height * 32 && !ver ? (h - map.height * 32) / 2 : 0
dh = ver ? h : [h, map.height * 32].min
resize(Rect.new(dx, dy, dw, dh))
end
#--------------------------------------------------------------------------
# ● New method: x, y, width, height
#--------------------------------------------------------------------------
define_sec_method(:x) { self.rect.x }
define_sec_method(:y) { self.rect.y }
define_sec_method(:width) { self.rect.width }
define_sec_method(:height) { self.rect.height }
define_sec_method(:x=) {|x2| resize(x2,y,width,height) }
define_sec_method(:y=) {|y2| resize(x,y2,width,height) }
define_sec_method(:width=) {|w1| resize(x,y,w1,height) }
define_sec_method(:height=) {|h1| resize(x,y,width,h1) }
end
#==============================================================================
# ** Graphics
#------------------------------------------------------------------------------
# This module handles all Graphics
#==============================================================================
class << Graphics
#------------------------------------------------------------------------
# ● Include AutoUpdate
#------------------------------------------------------------------------
include_auto_update
#------------------------------------------------------------------------
# ● Redirect Listing
#------------------------------------------------------------------------
redirect_method :width, 'LiTTleDRAgo.client_size.at(0)'
redirect_method :height, 'LiTTleDRAgo.client_size.at(1)'
redirect_method :snap_to_bitmap, 'LiTTleDRAgo.snap_to_bitmap'
redirect_method :disable_alt_enter, 'LiTTleDRAgo.disable_alt_enter'
redirect_method :always_on_top, 'LiTTleDRAgo.always_on_top'
redirect_method :show_fps, 'LiTTleDRAgo.show_fps'
redirect_method :scale_screen, 'LiTTleDRAgo.scale_screen'
redirect_method :fill_monitor, 'LiTTleDRAgo.fill_monitor'
redirect_method :window, 'LiTTleDRAgo.window'
redirect_method :toggle, 'LiTTleDRAgo.toggle'
redirect_method :fullscreen, 'LiTTleDRAgo.fullscreen'
redirect_method :fullscreen?, 'LiTTleDRAgo.fullscreen?'
redirect_method :control_screen_size,'LiTTleDRAgo.control_screen_size'
redirect_method :high_priority, 'LiTTleDRAgo.high_priority'
redirect_method :high_priority=, 'LiTTleDRAgo.high_priority=args.at(0)'
#------------------------------------------------------------------------
# ● Alias Listing
#------------------------------------------------------------------------
alias_sec_method :resize_screen, :scale_screen
#--------------------------------------------------------------------------
# * New method: fadeoutviewport
#--------------------------------------------------------------------------
def fadeoutviewport
@fadeoutviewport ||= ((v = Viewport.new(0,0,width,height))
(v.color = (v.z = 0x3FFFFFFF) && Color.new(0,0,0,0)) && v)
end
#--------------------------------------------------------------------------
# ● Redefined method: wait, brightness
#--------------------------------------------------------------------------
define_sec_method(:wait) { |frame| frame.times {|i| update } }
define_sec_method(:brightness) { (255 - fadeoutviewport.color.alpha) }
#--------------------------------------------------------------------------
# * Redefined method: brightness= (Set Graphics Brightness)
#--------------------------------------------------------------------------
unless method_defined?(:brightness=)
def brightness=(value)
fadeoutviewport.color.alpha = 255 - value.clamp(0,255)
end
end
#--------------------------------------------------------------------------
# * Redefined method: fadein (Graphics Fade In)
# frame : frame of fade
#--------------------------------------------------------------------------
unless method_defined?(:fadein)
def fadein(frames = 10)
return if frames <= 0
curvalue, count = brightness, (255 - brightness)
frames.times do |i|
(self.brightness = curvalue + (count * i / frames)) && update
end
end
end
#--------------------------------------------------------------------------
# * Redefined method: fadeout (Graphics Fade Out)
# frame : frame of fade
#--------------------------------------------------------------------------
unless method_defined?(:fadeout)
def fadeout(frames = 10)
return if frames <= 0
curvalue = count = self.brightness
frames.times do |i|
(self.brightness = curvalue - (count * i / frames)) && update
end
end
end
#--------------------------------------------------------------------------
# * New method: wait_for_input
#--------------------------------------------------------------------------
unless method_defined?(:wait_for_input)
def wait_for_input
[Input,self].update
[Input,self].update until press_any_key
end
end
end
#==============================================================================
# ** Input
#------------------------------------------------------------------------------
# This module handles all Input
#==============================================================================
class << Input
#------------------------------------------------------------------------
# ● Include AutoUpdate
#------------------------------------------------------------------------
include_auto_update
#--------------------------------------------------------------------------
# ● Aliased method: :press?, :repeat?, :trigger?
#--------------------------------------------------------------------------
[:press?,:repeat?,:trigger?].each do |method|
next unless method_defined?(:"#{method}")
alias_sec_method(:"sym_#{method}", :"#{method}")
define_method(:"#{method}") do |*args|
if (b = args.first).is_a?(Symbol) || b.is_a?(String)
args[0] = Input.const_get("#{b}") rescue nil
end
(args.first.not.nil?) && send(:"sym_#{method}", *args)
end
end
end
#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
# This sprite is used to display the battler.It observes the Game_Character
# class and automatically changes sprite conditions.
#==============================================================================
class Sprite_Battler
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
define_pre_alias(:update) { @battler.nil? && @battler_name = nil }
end
#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
# This class brings together map screen sprites, tilemaps, etc.
# It's used within the Scene_Map class.
#==============================================================================
class Spriteset_Map
#--------------------------------------------------------------------------
# ● New method: sprite_player
#--------------------------------------------------------------------------
define_sec_method(:sprite_player) { find_character($game_player) }
#------------------------------------------------------------------------
# ● Public Instance Variables
#------------------------------------------------------------------------
attr_sec_reader :character_sprites, 'Array.new'
attr_reader :viewport1, :viewport2, :viewport3
#--------------------------------------------------------------------------
# * Aliased method: update
#--------------------------------------------------------------------------
define_pre_alias(:update) { update_viewport_size_change }
#--------------------------------------------------------------------------
# * New method: update_viewport_size_change
#--------------------------------------------------------------------------
def update_viewport_size_change
if viewport_size_change?
@viewport_map_width = $game_map.width
@viewport_map_height = $game_map.height
@viewport_screen_width = Graphics.width
@viewport_screen_height = Graphics.height
[@viewport1,@viewport2,@viewport3].compact.update_viewport_sizes
end
end
#--------------------------------------------------------------------------
# * New method: viewport_size_change?
#--------------------------------------------------------------------------
unless method_defined?(:viewport_size_change?)
def viewport_size_change?
return true if @viewport_map_width != $game_map.width
return true if @viewport_map_height != $game_map.height
return true if @viewport_screen_width != Graphics.width
return true if @viewport_screen_height != Graphics.height
end
end
#--------------------------------------------------------------------------
# ● New method: redraw_character_sprites
#--------------------------------------------------------------------------
unless method_defined?(:redraw_character_sprites)
def redraw_character_sprites
return refresh_characters if self.respond_to?(:refresh_characters)
character_sprites.dispose
@character_sprites = $game_map.events.keys.sort.map {|i|
Sprite_Character.new(@viewport1, $game_map.events[i]) }
@character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
end
end
#--------------------------------------------------------------------------
# ● New method: find_character
#--------------------------------------------------------------------------
unless method_defined?(:find_character)
def find_character(char)
character_sprites.detect { |s| s.character == char }
end
end
#---------------------------------------------------------------------------
# * New method: viewport_sprite
#---------------------------------------------------------------------------
def viewport_sprite(*v)
v.collect! {|s| s.is_a?(Symbol) ? instance_variable_get(:"@#{s}") : s }
v.reject! {|s| s.not.is_a?(Viewport)}
all = instance_variables.map {|s| instance_variable_get("#{s}")}.flatten
all.select {|s| s.respond_to?(:viewport) && v.include?(s.viewport)}
end
end
#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# This class deals with battlers. It's used as a superclass for the Game_Actor
# and Game_Enemy classes.
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● New method: alive?
#--------------------------------------------------------------------------
define_sec_method(:alive?) { self.not.dead? }
#--------------------------------------------------------------------------
# ● New method: hp_percent
#--------------------------------------------------------------------------
unless method_defined?(:hp_percent)
def hp_percent(integer = false, float_points = 2)
n = Math.percent(hp,(respond_to?(:mhp) ? mhp : maxhp))
return integer ? Integer(n) : n.float_points(float_points)
end
end
#--------------------------------------------------------------------------
# ● New method: sp_percent
#--------------------------------------------------------------------------
unless method_defined?(:sp_percent)
def sp_percent(integer = false, float_points = 2)
n = Math.percent((respond_to?(:sp) ? sp : mp),
((respond_to?(:mmp) ? mmp : (respond_to?(:maxsp) ? maxsp : maxmp))))
return integer ? Integer(n) : n.float_points(float_points)
end
alias_method :mp_percent, :sp_percent
end
end
#==============================================================================
# ** Game_Character
#------------------------------------------------------------------------------
# This class deals with characters. It's used as a superclass for the
# Game_Player and Game_Event classes.
#==============================================================================
class Game_Character
#--------------------------------------------------------------------------
# ● Redirect Listing
#--------------------------------------------------------------------------
redirect_method :move_down, 'move_straight(2,*args)'
redirect_method :move_left, 'move_straight(4,*args)'
redirect_method :move_right, 'move_straight(6,*args)'
redirect_method :move_up, 'move_straight(8,*args)'
redirect_method :turn_down, 'set_direction(2,*args)'
redirect_method :turn_left, 'set_direction(4,*args)'
redirect_method :turn_right, 'set_direction(6,*args)'
redirect_method :turn_up, 'set_direction(8,*args)'
redirect_method :move_lower_left, 'move_diagonal(4, 2,*args)'
redirect_method :move_lower_right, 'move_diagonal(6, 2,*args)'
redirect_method :move_upper_left, 'move_diagonal(4, 8,*args)'
redirect_method :move_upper_right, 'move_diagonal(6, 8,*args)'
redirect_method :character_sprite, '$game_map.character_sprite(self)'
redirect_method :character_above?, '(args.first.y > @y)'
redirect_method :character_below?, '(args.first.y < @y)'
redirect_method :character_right?, '(args.first.x < @x)'
redirect_method :character_left?, '(args.first.x > @x)'
redirect_method :pos, '[@x, @y]'
redirect_method :pos_nt?, '!@through && pos?'
redirect_method :normal_priority?, '@character_name != ""'
redirect_method :map_passable?, '$game_map.passable?'
redirect_method :map_terrain_tag, '$game_map.terrain_tag'
#--------------------------------------------------------------------------
# * Redefined method: pos?
# anime
# reverse_dir
#--------------------------------------------------------------------------
define_sec_method(:reverse_dir) {|dir| 10 - dir }
define_sec_method(:pos?) {|x,y| @x == x && @y == y }
define_sec_method(:anime) {|aid| @animation_id = aid }
#--------------------------------------------------------------------------
# ● Redefined method: check_event_trigger_touch_front
#--------------------------------------------------------------------------
unless method_defined?(:check_event_trigger_touch_front)
def check_event_trigger_touch_front
x2 = $game_map.round_x_with_direction(@x, @direction)
y2 = $game_map.round_y_with_direction(@y, @direction)
check_event_trigger_touch(x2, y2)
end
end
#--------------------------------------------------------------------------
# ● Redefined method: move_straight
#--------------------------------------------------------------------------
unless method_defined?(:move_straight)
def move_straight(d, turn_ok = true)
if passable?(@x, @y, d)
set_direction(d)
@x = $game_map.round_x_with_direction(@x, d)
@y = $game_map.round_y_with_direction(@y, d)
increase_steps
elsif turn_ok
set_direction(d)
check_event_trigger_touch_front
end
end
end
#--------------------------------------------------------------------------
# ● Redefined method: set_direction
#--------------------------------------------------------------------------
unless method_defined?(:set_direction)
def set_direction(d)
@direction = d unless @direction_fix || d == 0
@stop_count = 0
end
end
#--------------------------------------------------------------------------
# ● Redefined method: set_graphic
#--------------------------------------------------------------------------
unless method_defined?(:set_graphic)
def set_graphic(character_name, character_index = 0)
@tile_id = 0
@character_name = character_name
if self.respond_to?(:character_index)
@character_index = character_index
else
@character_hue = character_index
end
@original_pattern = 1
end
end
#--------------------------------------------------------------------------
# ● Redefined method: swap
#--------------------------------------------------------------------------
unless method_defined?(:swap)
def swap(character)
new_pos = character.pos
character.moveto(x, y)
moveto(*new_pos)
end
end
#--------------------------------------------------------------------------
# ● Redefined method: rotate_swap_prev
#--------------------------------------------------------------------------
unless method_defined?(:rotate_swap_prev)
def rotate_swap_prev(*character)
character.unshift(self)
position = character.collect {|c| c.pos}
character.each_with_index { |c,i| c.moveto(*position[i-1]) }
end
end
#--------------------------------------------------------------------------
# ● Redefined method: rotate_swap_next
#--------------------------------------------------------------------------
unless method_defined?(:rotate_swap_next)
def rotate_swap_next(*character)
character.unshift(self)
position = character.collect {|c| c.pos}
character.each_with_index do |char,index|
char.moveto(*position[index + 1 >= position.size ? 0 : index + 1])
end
end
end
#--------------------------------------------------------------------------
# ● New method: distance_from
#--------------------------------------------------------------------------
unless method_defined?(:distance_from)
def distance_from(character,type= 'xy')
character = $game_map.events[character] if character.is_a?(Integer)
return 0 if character.nil?
return (@x - character.x).abs if type.to_s == 'x'
return (@y - character.y).abs if type.to_s == 'y'
return Math.hypot(@x - character.x, @y - character.y)
end
end
#--------------------------------------------------------------------------
# * Redefined method: distance_x_from
#--------------------------------------------------------------------------
unless method_defined?(:distance_x_from)
def distance_x_from(x)
result = @x - x
if result.abs > $game_map.width / 2
result += result < 0 ? $game_map.width : -$game_map.width
end
result
end
end
#--------------------------------------------------------------------------
# * Redefined method: distance_y_from
#--------------------------------------------------------------------------
unless method_defined?(:distance_y_from)
def distance_y_from(y)
result = @y - y
if result.abs > $game_map.height / 2
result += result < 0 ? $game_map.height : -$game_map.height
end
result
end
end
#--------------------------------------------------------------------------
# ● New method: random_teleport
#--------------------------------------------------------------------------
unless method_defined?(:random_teleport)
def random_teleport
1000.times do
moveto(rand($game_map.height), rand($game_map.width))
vx = LiTTleDRAgo::VX && !LiTTleDRAgo::VXA
arg = vx ? [@x,@y] : [@x,@y,@direction]
break if passable?(*arg)
end || true
end
end
#--------------------------------------------------------------------------
# * Redefined method: diagonal_passable? (for RMXP)
# horz : Horizontal (4 or 6)
# vert : Vertical (2 or 8)
#--------------------------------------------------------------------------
unless method_defined?(:diagonal_passable?)
def diagonal_passable?(x, y, horz, vert)
x2 = $game_map.round_x_with_direction(x, horz)
y2 = $game_map.round_y_with_direction(y, vert)
(passable?(x, y, vert) && passable?(x, y2, horz)) ||
(passable?(x, y, horz) && passable?(x2, y, vert))
end
end
#--------------------------------------------------------------------------
# * Redefined method: collide_with_characters? (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:collide_with_characters?)
def collide_with_characters?(x, y)
collide_with_events?(x, y)
end
end
#--------------------------------------------------------------------------
# * Redefined method: collide_with_events? (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:collide_with_events?)
def collide_with_events?(x, y)
$game_map.events_xy_nt(x, y).any? do |event|
event.normal_priority? || self.is_a?(Game_Event)
end
end
end
#--------------------------------------------------------------------------
# * Redefined method: debug_through?
#--------------------------------------------------------------------------
unless method_defined?(:debug_through?)
def debug_through?
debug = LiTTleDRAgo::VX ? $TEST : $DEBUG
return debug && Input.press?(Input::CTRL) if self.is_a?(Game_Player)
return false
end
end
end
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles actors. It is used within the Game_Actors class
# ($game_actors), also referenced from the Game_Party class ($game_party).
#==============================================================================
class Game_Actor
#--------------------------------------------------------------------------
# * Get Actor Object
#--------------------------------------------------------------------------
define_sec_method(:actor) { $data_actors[@actor_id] }
define_method(:class) { $data_classes[@class_id] }
end
#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemies. It used within the Game_Troop class
# ($game_troop).
#==============================================================================
class Game_Enemy
#--------------------------------------------------------------------------
# * Get Enemy Object
#--------------------------------------------------------------------------
define_sec_method(:enemy) { $data_enemies[@enemy_id] }
end
#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
# This class handles the player. It includes event starting determinants and
# map scrolling functions. The instance of this class is referenced by
# $game_player.
#==============================================================================
class Game_Player
#--------------------------------------------------------------------------
# ● Redefined method: actor
# name
#--------------------------------------------------------------------------
define_sec_method(:actor) { $game_party.leader }
define_sec_method(:name) { actor.name }
#--------------------------------------------------------------------------
# ● New method: method_missing
#--------------------------------------------------------------------------
def method_missing(val,*a,&b)
return actor.send(val.to_s,*a,&b) if actor.respond_to?(val.to_sym)
text = "Undefined method #{val} for #{self.inspect}"
raise(NoMethodError, text, caller(1))
end
end
#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
# This class deals with events. It handles functions including event page
# switching via condition determinants, and running parallel process events.
# It's used within the Game_Map class.
#==============================================================================
class Game_Event < Game_Character
#--------------------------------------------------------------------------
# ● Public Instance Variables
#--------------------------------------------------------------------------
method_defined?(:erased) || (attr_reader :erased)
method_defined?(:id) || (attr_reader :id)
method_defined?(:event) || (attr_reader :event)
attr_accessor :loaded_event
#--------------------------------------------------------------------------
# ● New method: name
# ● New method: restore
#--------------------------------------------------------------------------
define_sec_method(:name) { @event.name }
define_sec_method(:restore) { (@erased = false) || refresh }
#--------------------------------------------------------------------------
# ● New method: destroy
#--------------------------------------------------------------------------
unless method_defined?(:destroy)
def destroy
event = $game_map.events.delete(@id)
if (s = $game_map.spriteset).is_a?(Spriteset_Map)
after = s.character_sprites.select { |e| e if e.character != event }
(delet = character_sprite) && delet.dispose
s.character_sprites.replace(after)
end
end
end
#--------------------------------------------------------------------------
# ● New method: eliminate
#--------------------------------------------------------------------------
unless method_defined?(:eliminate)
def eliminate
return destroy if self.loaded_event
(eliminate = $game_map.eliminate_event)[(id = $game_map.map_id)] ||= []
(eliminate[id].include?(@id) || eliminate[id].push(@id)) && destroy
end
end
#--------------------------------------------------------------------------
# ● New method: note
#--------------------------------------------------------------------------
unless method_defined?(:note)
def note
list = @page ? @page.list.select {|l| [108,408].include?(l.code)} : []
notes = list.collect {|l| l.parameters[0] }.join("\n")
return notes
end
end
#--------------------------------------------------------------------------
# ● New method: proper_page_index
#--------------------------------------------------------------------------
unless method_defined?(:proper_page_index)
def proper_page_index
if respond_to?(:conditions_met?)
page = respond_to?(:find_proper_page) ? find_proper_page :
@event.pages.reverse.find {|page| conditions_met?(page)}
(i = @event.pages.index(page)).is_a?(Integer) ? i + 1 : 0
end
end
end
end
#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
# This class handles the party. It includes information on amount of gold
# and items. Refer to "$game_party" for the instance of this class.
#==============================================================================
class Game_Party
#--------------------------------------------------------------------------
# ● Alias Listing
#--------------------------------------------------------------------------
alias_sec_method :drg_ce_item_number, :item_number
#--------------------------------------------------------------------------
# ● Redirect Listing
#--------------------------------------------------------------------------
redirect_method :player_pos, '($game_player.pos)'
redirect_method :leader, '(members.first)'
redirect_method :members, '(actors)'
redirect_method :actors, '(members)'
#--------------------------------------------------------------------------
# ● New method: existing_actors, recover_all
#--------------------------------------------------------------------------
define_sec_method(:existing_actors) { members.find_all {|a| a.exist?} }
define_sec_method(:recover_all) { members.each {|a| a.recover_all} }
#--------------------------------------------------------------------------
# ● New method: has_actors?
#--------------------------------------------------------------------------
unless method_defined?(:has_actors?)
def has_actors?(*actors)
party = @actors.collect {|s| s.is_a?(Game_Actor) ? s.id : s }
actor = actors.collect {|s| s.is_a?(Game_Actor) ? s.id : s }.flatten
return party.have_all?(*actor)
end
end
#--------------------------------------------------------------------------
# ● New method: has_any_actors?
#--------------------------------------------------------------------------
unless method_defined?(:has_any_actors?)
def has_any_actors?(*actors)
party = @actors.collect {|s| s.is_a?(Game_Actor) ? s.id : s }
actor = actors.collect {|s| s.is_a?(Game_Actor) ? s.id : s }.flatten
return party.have_any?(*actor)
end
end
#--------------------------------------------------------------------------
# ● New method: swap_previous_actor
#--------------------------------------------------------------------------
unless method_defined?(:swap_leader_prev)
def swap_leader_prev(n = 1)
n <= 0 || n.round.times { @actors.previous_item && drg_ce_refresh }
n >= 0 || swap_leader_next(n.round.abs)
end
end
#--------------------------------------------------------------------------
# ● New method: swap_next_actor
#--------------------------------------------------------------------------
unless method_defined?(:swap_leader_next)
def swap_leader_next(n = 1)
n <= 0 || n.round.times { @actors.next_item && drg_ce_refresh }
n >= 0 || swap_leader_prev(n.round.abs)
end
end
#--------------------------------------------------------------------------
# ● New method: set_leader
#--------------------------------------------------------------------------
unless method_defined?(:set_leader)
def set_leader(id)
actor = id.is_a?(Numeric) ? $game_actors[id.to_i] : id
if actor.is_a?(Game_Actor) && has_actors?(actor.id)
swap_leader_next until $game_party.leader.id == actor.id
actor.id
end
end
end
#--------------------------------------------------------------------------
# ● New method: drg_ce_refresh
#--------------------------------------------------------------------------
unless method_defined?(:drg_ce_refresh)
def drg_ce_refresh
return refresh if respond_to?(:refresh)
return ($game_map.need_refresh = true) && $game_player.refresh
end
end
#--------------------------------------------------------------------------
# * Get Party Name
#--------------------------------------------------------------------------
unless method_defined?(:name)
def name
return "" if existing_actors.size == 0
return leader.name if existing_actors.size == 1
return "#{leader.name}'s Party"
end
end
#--------------------------------------------------------------------------
# * Aliased method: item_number
#--------------------------------------------------------------------------
def item_number(item)
unless LiTTleDRAgo::VX
return drg_ce_item_number(item.id) if item.is_a?(RPG::Item)
return weapon_number(item.id) if item.is_a?(RPG::Weapon)
return armor_number(item.id) if item.is_a?(RPG::Armor)
else
item = $data_items[item.to_i] if item.is_a?(Numeric)
end
return skill_number(item) if item.is_a?(RPG::Skill)
return drg_ce_item_number(item)
end
#--------------------------------------------------------------------------
# * Redefined method: weapon_number
#--------------------------------------------------------------------------
unless method_defined?(:weapon_number)
def weapon_number(weapon)
weapon = $data_weapons[weapon.to_i] if weapon.is_a?(Numeric)
item_number(weapon)
end
end
#--------------------------------------------------------------------------
# * Redefined method: armor_number
#--------------------------------------------------------------------------
unless method_defined?(:armor_number)
def armor_number(armor)
armor = $data_armors[armor.to_i] if armor.is_a?(Numeric)
item_number(armor)
end
end
#--------------------------------------------------------------------------
# * New method: skill_number
#--------------------------------------------------------------------------
unless method_defined?(:skill_number)
def skill_number(skill)
skill = $data_skills[skill.to_i] if skill.is_a?(Numeric)
s1 = actors.select {|a| a.skill_learn?(skill) }
s2 = actors.select {|a| a.skill_learn?(skill.id) }
return s1.size + s2.size
end
end
#--------------------------------------------------------------------------
# * New method: gain_all_items
#--------------------------------------------------------------------------
def gain_all_items(ammount=1)
(0..999).to_a.each do |s|
next if $data_items[s].nil? || $data_items[s].name == ''
$game_party.drg_ce_get_item($data_items[s],ammount)
end
end
#--------------------------------------------------------------------------
# * New method: gain_all_weapons
#--------------------------------------------------------------------------
def gain_all_weapons(ammount=1)
(0..999).to_a.each do |s|
next if $data_weapons[s].nil? || $data_weapons[s].name == ''
drg_ce_get_item($data_weapons[s],ammount)
end
end
#--------------------------------------------------------------------------
# * New method: gain_all_armors
#--------------------------------------------------------------------------
def gain_all_armors(ammount=1)
(0..999).to_a.each do |s|
next if $data_armors[s].nil? || $data_armors[s].name == ''
drg_ce_get_item($data_armors[s],ammount)
end
end
#--------------------------------------------------------------------------
# * New method: drg_ce_get_item
#--------------------------------------------------------------------------
def drg_ce_get_item(item,ammount)
return gain_item(item,ammount) if LiTTleDRAgo::VX
return gain_item(item.id,ammount) if item.is_a?(RPG::Item)
return gain_weapon(item.id,ammount) if item.is_a?(RPG::Weapon)
return gain_armor(item.id,ammount) if item.is_a?(RPG::Armor)
end
end
#==============================================================================
# ** Game_Follower
#------------------------------------------------------------------------------
# This class handles followers. A follower is an allied character, other than
# the front character, displayed in the party. It is referenced within the
# Game_Followers class.
#==============================================================================
class Game_Follower < Game_Character
#--------------------------------------------------------------------------
# * Redirect Listing
#--------------------------------------------------------------------------
redirect_method :name, "(actor.nil? ? '' : actor.name)"
end if defined?(Game_Follower)
#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
# This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_sec_reader :eliminate_event, 'Hash.new'
#--------------------------------------------------------------------------
# ● New method: name, parent_id, base_parent_id
# event_list , map_events
#--------------------------------------------------------------------------
define_sec_method(:name) { mapInfo[@map_id].name }
define_sec_method(:parent_id) { mapInfo[@map_id].parent_id }
define_sec_method(:base_parent_id) { search_parent_id(mapInfo) }
define_sec_method(:event_list) { events.values }
define_sec_method(:map_events) { @map.events }
define_sec_method(:screen) { $game_screen }
define_sec_method(:loop_horizontal?) { false }
define_sec_method(:loop_vertical?) { false }
define_sec_method(:map_child?) { |*a| a & child_ids == a }
#--------------------------------------------------------------------------
# * Aliased method: setup
#--------------------------------------------------------------------------
define_post_alias(:setup) do
eliminate_event[@map_id] ||= []
eliminate_event[@map_id].each { |s| events.delete(s) }
end
#--------------------------------------------------------------------------
# * Redefined method: any_event_strarting? (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:any_event_starting?)
def any_event_starting?
event_list.any? {|event| event.starting }
end
end
#--------------------------------------------------------------------------
# * Redefined method: interpreter (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:interpreter)
def interpreter
return $game_system.map_interpreter if LiTTleDRAgo.scene.is_a?(Scene_Map)
return $game_system.battle_interpreter
end
end
#--------------------------------------------------------------------------
# * Redefined method: events_xy (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:events_xy)
def events_xy(x, y)
event_list.select {|event| event.x == x && event.y == y }
end
end
#--------------------------------------------------------------------------
# * Redefined method: events_xy_nt (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:events_xy_nt)
def events_xy_nt(x, y)
event_list.select {|event| event.pos_nt?(x, y) }
end
end
#--------------------------------------------------------------------------
# * Redefined method: round_x, round_y (for RMXP)
#--------------------------------------------------------------------------
define_sec_method(:round_x) {|x| loop_horizontal? ? (x + width) % width : x }
define_sec_method(:round_y) {|y| loop_vertical? ? (y + height) % height : y }
#--------------------------------------------------------------------------
# * Redefined method: x_with_direction (for RMXP)
#--------------------------------------------------------------------------
define_sec_method(:x_with_direction) {|x, d| x + (d==6 ? 1 : d==4 ? -1 : 0)}
define_sec_method(:y_with_direction) {|y, d| y + (d==2 ? 1 : d==8 ? -1 : 0)}
#--------------------------------------------------------------------------
# * Redefined method: round_x_with_direction (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:round_x_with_direction)
def round_x_with_direction(x, d)
round_x(x_with_direction(x, d))
end
end
#--------------------------------------------------------------------------
# * Redefined method: round_y_with_direction (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:round_y_with_direction)
def round_y_with_direction(y, d)
round_y(y_with_direction(y, d))
end
end
#--------------------------------------------------------------------------
# * New method: x_diagonal_with_direction (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:x_diagonal_with_direction)
def x_diagonal_with_direction(x, d)
x + ([9,6,3].include?(d) ? 1 : [7,4,1].include?(d) ? -1 : 0)
end
end
#--------------------------------------------------------------------------
# * New method: y_with_direction (for RMXP)
#--------------------------------------------------------------------------
unless method_defined?(:y_diagonal_with_direction)
def y_diagonal_with_direction(y, d)
y + ([1,2,3].include?(d) ? 1 : [7,8,9].include?(d) ? -1 : 0)
end
end
#--------------------------------------------------------------------------
# ● New method: existing_events
#--------------------------------------------------------------------------
unless method_defined?(:existing_events)
def existing_events
event_list.select {|e| e.not.erased }
end
end
#--------------------------------------------------------------------------
# ● New method: map_info
#--------------------------------------------------------------------------
unless method_defined?(:mapInfo)
def mapInfo(ext = LiTTleDRAgo.data_default_extension)
data = "Data/MapInfos.#{ext}"
@mapinfo ||= load_data(sprintf("#{data}")) rescue draise(
"Fail to load #{data}")
return @mapinfo
end
end
#--------------------------------------------------------------------------
# ● New method: search_parent_id
#--------------------------------------------------------------------------
unless method_defined?(:search_parent_id)
def search_parent_id(mapInfo, id = @map_id, ancestor = 0)
m_id = id
loop do
_m_id = mapInfo[m_id]
p_id = _m_id.respond_to?(:parent_id) ? _m_id.parent_id : nil
return p_id if p_id == nil
return m_id if p_id == ancestor
m_id = p_id
end
end
end
#--------------------------------------------------------------------------
# ● New method: base_map_name
#--------------------------------------------------------------------------
unless method_defined?(:base_map_name)
def base_map_name
map = mapInfo[search_parent_id(mapInfo)]
name = map.respond_to?(:name) ? map.name : ''
return name
end
end
#--------------------------------------------------------------------------
# ● New method: child_ids
#--------------------------------------------------------------------------
unless method_defined?(:child_ids)
def child_ids
mapInfo.keys.select {|map_id| mapInfo[map_id].parent_id == @map_id }
end
end
#--------------------------------------------------------------------------
# ● New method: descendant?
#--------------------------------------------------------------------------
unless method_defined?(:map_descendant?)
def map_descendant?(*a)
a.all? {|map_id| search_parent_id(mapInfo, map_id, @map_id)}
end
end
#--------------------------------------------------------------------------
# ● New method: load_event
#--------------------------------------------------------------------------
unless method_defined?(:load_event)
def load_event(*a)
case a.size
when 5, 4 then (mapid, eventid, x, y = *a)
when 3 then (mapid = @map_id) && (eventid, x, y = *a)
when 2 then (mapid, y = @map_id, 0) && (eventid, x = *a)
when 1 then (mapid, x, y = @map_id, 0,0) && (eventid = a.first)
when 0 then return nil
end
map = load_map_data(mapid)
event = map.events.values.detect { |event| event.id == eventid }
unless event.nil?
(a = a.at(4)) && (b = [a].flatten) && event.pages.reject! do |s|
c = b.map {|i| i.is_a?(Range) ? i.to_a : i }
c.flatten.not.include?(event.pages.index(s)+1)
end
return nil if event.pages.empty?
c,r = [Array,Range], []
c.include?(x.class) && (x = x.to_a.map{|s|s.is_a?(Range) ? s.to_a : s})
c.include?(y.class) && (y = y.to_a.map{|s|s.is_a?(Range) ? s.to_a : s})
[x].flatten.dproduct([y].flatten).each do |x1,y1|
event.instance_variable_set(:@id,(id = next_key_events))
r.push(@events[id] = e = Game_Event.new(@map_id, event.clone))
e.loaded_event = true
e.moveto(x1,y1)
end
a = r.size == 1 ? r.first : r
if r && (s = spriteset).is_a?(Spriteset_Map)
sc = s.character_sprites
after = sc.select { |e| e if e.character != $game_player }
player = s.sprite_player
sc.replace(after)
r.each {|e| sc.push(Sprite_Character.new(s.viewport1, e)) }
sc.push(player)
end
return a
end
end
end
#--------------------------------------------------------------------------
# ● New method: call_event
#--------------------------------------------------------------------------
unless method_defined?(:call_event)
def call_event(*a)
case a.size
when 3 then (mapid, eventid, page_id = *a)
when 2 then (page_id = -1) && (mapid, eventid = *a)
when 1 then (mapid, page_id = @map_id, -1) && (eventid = a.first)
when 0 then return nil
end
map = load_map_data(mapid)
event = map.events.values.detect { |event| event.id == eventid }
unless event.nil?
if page_id == -1 && event.respond_to?(:conditions_met?)
pages = event.pages.reverse.find {|page| event.conditions_met?(page)}
else
pages = event.pages[[page_id,1].max-1]
end
klass = LiTTleDRAgo::VX ? Game_Interpreter : Interpreter
child = klass.new(interpreter.instance_variable_get(:@depth) + 1)
child.setup(pages.list, interpreter.same_map? ? event.id : 0)
if LiTTleDRAgo::VXA
child.run rescue FiberError
else
interpreter.instance_variable_set(:@child_interpreter, child)
end
end
end
end
#--------------------------------------------------------------------------
# ● New method: load_map_data
#--------------------------------------------------------------------------
unless method_defined?(:load_map_data)
def load_map_data(mapid, ext = LiTTleDRAgo.data_default_extension)
(map = sprintf("Data/Map%03d.#{ext}", mapid)) && load_data(map)
end
end
#--------------------------------------------------------------------------
# ● New method: increment_key_events
#--------------------------------------------------------------------------
unless method_defined?(:next_key_events)
def next_key_events
(@events.keys.max || 0) + 1
end
end
#--------------------------------------------------------------------------
# ● New method: unused_key_events
#--------------------------------------------------------------------------
unless method_defined?(:unused_key_events)
def unused_key_events(start = 1)
start = [start, next_key_events].min
(start..next_key_events).detect {|i| @events.keys.not.include?(i)}
end
end
#--------------------------------------------------------------------------
# ● New method: spriteset
#--------------------------------------------------------------------------
unless method_defined?(:spriteset)
def spriteset
LiTTleDRAgo.scene.instance_variable_get(:@spriteset)
end
end
#--------------------------------------------------------------------------
# ● New method: character_sprite
#--------------------------------------------------------------------------
unless method_defined?(:character_sprite)
def character_sprite(id = 0)
return unless spriteset.is_a?(Spriteset_Map)
id = id.is_a?(Game_Character) ? id : id == 0 ? $game_player : events[id]
spriteset.find_character(id)
end
end
#--------------------------------------------------------------------------
# ● New method: picture_sprite
#--------------------------------------------------------------------------
unless method_defined?(:picture_sprite)
def picture_sprite(id = nil)
return unless spriteset.is_a?(Spriteset_Map)
spriteset.update_pictures if spriteset.respond_to?(:update_pictures)
result = spriteset.instance_variable_get(:@picture_sprites)
id.nil? ? result : result[id]
end
end
end
#==============================================================================
# ■ RPG::Cache
#------------------------------------------------------------------------------
#
#==============================================================================
ModCache = LiTTleDRAgo.cache
class << ModCache
#-----------------------------------------------------------------------
# ● New method: self.draw_text
#-----------------------------------------------------------------------
unless method_defined?(:draw_text)
def draw_text(
width, height, text,
font = Font.default_name,
size = Font.default_size,
bold = Font.default_bold,
italic = Font.default_italic,
color = Font.default_color,
edging = false
)
cache_index = "text_" + width.to_s + height.to_s + text
font_text = ""
font.size.times do |i|
font_text += font[i].to_s
end
cache_index += font_text + size.to_s + bold.to_s + italic.to_s
cache_index += "#{color.red}#{color.blue}#{color.green}#{color.alpha}"
@cache ||= {}
if @cache[cache_index].nil? or @cache[cache_index].disposed?
bitmap = Bitmap.new(width, height)
bitmap.font.name = font
bitmap.font.size = size
bitmap.font.bold = bold
bitmap.font.italic = italic
bitmap.font.color = color
if edging
bitmap.draw_edging_text(0, 0, width, height, text, 0)
else
bitmap.draw_text(0, 0, width, height, text, 0)
end
@cache[cache_index] = bitmap
end
return @cache[cache_index]
end
end
#-----------------------------------------------------------------------
# ● New method: self.method_missing
#-----------------------------------------------------------------------
def method_missing(val,*a,&b)
if a.at(0).is_a?(String) && a.size <= 2
return load_bitmap("Graphics/#{val}/",*a,&b)
end
modified = [:invert,:brighten,:darken,:grayscale,:pixelate,:frost]
if modified.include?(a.first) && a.at(1).is_a?(String) && a.size <= 3
method = a.shift
filename = a.join + "-#{method}"
unless drago_bitmap_exist?("Graphics/#{val}",filename)
bitmap = load_bitmap("Graphics/#{val}/",*a,&b)
drago_set_bitmap(bitmap.send(method),"Graphics/#{val}",filename)
end
return drago_get_bitmap("Graphics/#{val}",filename)
end
text = "Undefined method #{val} for #{self.inspect}"
raise(NoMethodError, text, caller(1))
end
#-----------------------------------------------------------------------
# ● New method: drago_get_bitmap
#-----------------------------------------------------------------------
def drago_get_bitmap(folder_name, filename = '', hue = 0)
return empty_bitmap if filename.not.is_a?(String) || filename.empty?
path = LiTTleDRAgo::APPPATHDRAGO + "#{folder_name}/"
path = path.gsub("\\","/").gsub("//","/")
last = filename.split('.').last
filename.gsub!(".png","") if last.is_a?(String) && last[/png/i]
load_bitmap_no_rescue(path.downcase,filename.downcase,hue)
end
#-----------------------------------------------------------------------
# ● New method: drago_set_bitmap
#-----------------------------------------------------------------------
def drago_set_bitmap(bitmap, folder_name = '', filename = 'bitmap')
path = LiTTleDRAgo::APPPATHDRAGO + "#{folder_name}/"
path = path.gsub("\\","/").gsub("//","/")
last = filename.split('.').last
filename += '.png' unless last.is_a?(String) && last[/png/i]
Dir.make_dir(path) unless FileTest.directory?(path)
bitmap.export(path + filename)
drago_get_bitmap(folder_name, filename)
end
#-----------------------------------------------------------------------
# ● New method: drago_bitmap_exist?
#-----------------------------------------------------------------------
def drago_bitmap_exist?(folder_name, filename)
return false if filename.not.is_a?(String) || filename.empty?
path = LiTTleDRAgo::APPPATHDRAGO + "#{folder_name}/"
path = path.gsub("\\","/").gsub("//","/")
last = filename.split('.').last
filename += '.png' unless last.is_a?(String) && last[/png/i]
FileTest.file?(path + filename)
end
#--------------------------------------------------------------------------
# * Load Bitmap
#--------------------------------------------------------------------------
define_sec_method(:load_bitmap_no_rescue) do |folder, file, *a|
@cache ||= {}
if file.empty?
empty_bitmap
elsif (hue = a.first).is_a?(Numeric) && hue != 0
hue_changed_bitmap(folder + file, hue.round)
else
normal_bitmap(folder + file)
end
end
#--------------------------------------------------------------------------
# * Create Empty Bitmap
#--------------------------------------------------------------------------
define_sec_method(:empty_bitmap) { Bitmap.new(32, 32)}
#--------------------------------------------------------------------------
# * Create/Get Normal Bitmap
#--------------------------------------------------------------------------
define_sec_method(:normal_bitmap) do |path|
@cache[path] = Bitmap.new(path) unless include?(path)
@cache[path]
end
#--------------------------------------------------------------------------
# * Create/Get Hue-Changed Bitmap
#--------------------------------------------------------------------------
define_sec_method(:hue_changed_bitmap) do |path, hue|
key = [path, hue]
unless include?(key)
@cache[key] = normal_bitmap(path).clone
@cache[key].hue_change(hue)
end
@cache[key]
end
#--------------------------------------------------------------------------
# * Check Cache Existence
#--------------------------------------------------------------------------
def include?(key)
@cache[key] && @cache[key].not.disposed?
end
end
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
# This class is for all in-game windows.
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# * Redirect Listing
#--------------------------------------------------------------------------
redirect_method :draw_text, 'contents.draw_text'
redirect_method :text_size, 'contents.text_size'
redirect_method :change_color, 'contents.change_color'
redirect_method :draw_picture, 'contents.draw_picture'
redirect_method :draw_icon, 'contents.draw_icon'
redirect_method :draw_battler, 'contents.draw_battler'
#--------------------------------------------------------------------------
# * Redefined method: line_height, translucent_alpha
# * New method: show, hide, activate, deactivate
#--------------------------------------------------------------------------
define_sec_method(:line_height) { 32 }
define_sec_method(:translucent_alpha) { 160 }
define_sec_method(:show) { self.visible = true }
define_sec_method(:hide) { self.visible = false }
define_sec_method(:activate) { self.active = true }
define_sec_method(:deactivate) { self.active = false }
#--------------------------------------------------------------------------
# * New method: center_window
#--------------------------------------------------------------------------
unless method_defined?(:center_window)
def center_window
self.x = Graphics.width/2 - self.width/2
self.y = Graphics.height/2 - self.height/2
end
end
#--------------------------------------------------------------------------
# * Redefined method: disabled_color
#--------------------------------------------------------------------------
unless method_defined?(:disabled_color)
def disabled_color
color = normal_color
color.alpha = 128
return color
end
end
#--------------------------------------------------------------------------
# * Redefined method: draw_text_ex
#--------------------------------------------------------------------------
unless method_defined?(:draw_text_ex)
def draw_text_ex(x, y, text)
reset_font_settings
text = convert_escape_characters(text)
pos = {:x => x, :y => y, :new_x => x, :height => calc_line_height(text)}
process_character(text.slice!(0, 1), text, pos) until text.empty?
end
end
#--------------------------------------------------------------------------
# * Redefined method: reset_font_settings
#--------------------------------------------------------------------------
unless method_defined?(:reset_font_settings)
def reset_font_settings
change_color(normal_color)
contents.font.size = Font.default_size
contents.font.bold = Font.default_bold
contents.font.italic = Font.default_italic
end
end
#--------------------------------------------------------------------------
# * Redefined method: convert_escape_characters
#--------------------------------------------------------------------------
unless method_defined?(:convert_escape_characters)
def convert_escape_characters(text)
result = text.to_s.clone
result.gsub!(/\\/) { "\e" }
result.gsub!(/\e\e/) { "\\" }
result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] }
result.gsub!(/\eN\[(\d+)\]/i) { actor_name($1.to_i) }
result.gsub!(/\eP\[(\d+)\]/i) { party_member_name($1.to_i) }
result.gsub!(/\eG/i) { currency_unit }
result
end
end
#--------------------------------------------------------------------------
# * Redefined method: actor_name
#--------------------------------------------------------------------------
unless method_defined?(:actor_name)
def actor_name(n)
actor = n >= 1 ? $game_actors[n] : nil
actor ? actor.name : ""
end
end
#--------------------------------------------------------------------------
# * Redefined method: party_member_name
#--------------------------------------------------------------------------
unless method_defined?(:party_member_name)
def party_member_name(n)
actor = n >= 1 ? $game_party.instance_variable_get(:@actors)[n - 1] : nil
actor ? actor.name : ""
end
end
#--------------------------------------------------------------------------
# * Redefined method: process_character
#--------------------------------------------------------------------------
unless method_defined?(:process_character)
def process_character(c, text, pos)
case c
when "\n" # New line
process_new_line(text, pos)
when "\f" # New page
process_new_page(text, pos)
when "\e" # Control character
process_escape_character(obtain_escape_code(text), text, pos)
else # Normal character
process_normal_character(c, pos)
end
end
end
#--------------------------------------------------------------------------
# * Redefined method: process_normal_character
#--------------------------------------------------------------------------
unless method_defined?(:process_normal_character)
def process_normal_character(c, pos)
text_width = text_size(c).width
draw_text(pos[:x], pos[:y], text_width * 2, pos[:height], c)
pos[:x] += text_width
end
end
#--------------------------------------------------------------------------
# * Redefined method: process_new_line
#--------------------------------------------------------------------------
unless method_defined?(:process_new_line)
def process_new_line(text, pos)
pos[:x] = pos[:new_x]
pos[:y] += pos[:height]
pos[:height] = calc_line_height(text)
end
end
#--------------------------------------------------------------------------
# * Redefined method: process_new_page
#--------------------------------------------------------------------------
unless method_defined?(:process_new_page)
def process_new_page(text, pos)
end
end
#--------------------------------------------------------------------------
# * Redefined method: obtain_escape_code
#--------------------------------------------------------------------------
unless method_defined?(:obtain_escape_code)
def obtain_escape_code(text)
text.slice!(/^[\$\.\|\^!><\{\}\\]|^[\/\w+\/]+/i)
end
end
#--------------------------------------------------------------------------
# * Redefined method: obtain_escape_param
#--------------------------------------------------------------------------
unless method_defined?(:obtain_escape_param)
def obtain_escape_param(text)
text.slice!(/^\[\d+\]/)[/\d+/].to_i rescue 0
end
end
#--------------------------------------------------------------------------
# * Redefined method: process_escape_character
#--------------------------------------------------------------------------
unless method_defined?(:process_escape_character)
def process_escape_character(code, text, pos)
case code.upcase
when 'C' then change_color(text_color(obtain_escape_param(text)))
when 'I' then process_draw_icon(obtain_escape_code(text), pos)
when '{' then make_font_bigger
when '}' then make_font_smaller
end
end
end
#--------------------------------------------------------------------------
# * Redefined method: process_draw_icon
#--------------------------------------------------------------------------
unless method_defined?(:process_draw_icon)
def process_draw_icon(icon_index, pos)
icon_index = icon_index.to_i if icon_index.to_i.to_s == icon_index
draw_icon(icon_index, pos[:x], pos[:y])
pos[:x] += 24
end
end
#--------------------------------------------------------------------------
# * Redefined method: make_font_bigger
#--------------------------------------------------------------------------
unless method_defined?(:make_font_bigger)
def make_font_bigger
contents.font.size += 8 if contents.font.size <= 64
end
end
#--------------------------------------------------------------------------
# * Redefined method: make_font_smaller
#--------------------------------------------------------------------------
unless method_defined?(:make_font_smaller)
def make_font_smaller
contents.font.size -= 8 if contents.font.size >= 16
end
end
#--------------------------------------------------------------------------
# * Redefined method: calc_line_height
#--------------------------------------------------------------------------
unless method_defined?(:calc_line_height)
def calc_line_height(text, restore_font_size = true)
result = [line_height, contents.font.size].max
last_font_size = contents.font.size
text.slice(/^.*$/).scan(/\e[\{\}]/).each do |esc|
make_font_bigger if esc == "\e{"
make_font_smaller if esc == "\e}"
result = [result, contents.font.size].max
end
contents.font.size = last_font_size if restore_font_size
result
end
end
#--------------------------------------------------------------------------
# * New method: currency_unit
#--------------------------------------------------------------------------
unless method_defined?(:currency_unit)
def currency_unit
gold = $data_system.words.gold
return gold
end
end
#--------------------------------------------------------------------------
# ● New method: draw_map_name
#--------------------------------------------------------------------------
unless method_defined?(:draw_map_name)
def draw_map_name(x, y, width, height)
map_id = $game_map.map_id
mapInfo = $game_map.mapInfo
draw_text(x, y, width, height, mapInfo[map_id].name.to_s)
end
end
#--------------------------------------------------------------------------
# ● New method: draw_enter_text
#--------------------------------------------------------------------------
unless method_defined?(:draw_enter_text)
def draw_enter_text(x, y, width, height, text)
info_box = text.split(/\n/)
info_box.size.times do |i|
draw_text( x, y + i * line_height, width, line_height, info_box[i])
break if (y + i * line_height) > (self.height - line_height)
end
end
end
#--------------------------------------------------------------------------
# ● New method: draw_picture_number
#--------------------------------------------------------------------------
unless method_defined?(:draw_picture_number)
def draw_picture_number(x, y, value, file_name,align = 0,
space = 0, frame_max = 1,frame_index = 0)
number_image = LiTTleDRAgo.cache.windowskin(file_name)
frame_max = [frame_max, 1].max
frame_index = frame_max - 1 if frame_index > frame_max - 1
align = [[align,2].min,0].max
cw = number_image.width / 10
ch = number_image.height / frame_max
h = ch * frame_index
number = value.abs.to_s.split(//)
case align
when 0 then plus_x = (-cw + space) * number.size
when 1 then plus_x = ((-cw + space) * number.size) / 2
when 2 then plus_x = 0
end
for r in 0..number.size - 1
rect = Rect.new(cw * number[r].to_i, h, cw, ch)
contents.blt(plus_x + x + ((cw - space) * r), y , number_image, rect)
end
number_image.dispose
end
end
end
#==============================================================================
# ■ Bitmap
#------------------------------------------------------------------------------
#
#==============================================================================
class Bitmap
#----------------------------------------------------------------------------
# ● Constant
#----------------------------------------------------------------------------
RtlMoveMemory_pi = LiTTleDRAgo.rtlmemory_pi
RtlMoveMemory_ip = LiTTleDRAgo.rtlmemory_ip
Blur_Setting = "{ 'offset' => 2, 'spacing' => 1, 'opacity' => 255 }"
#----------------------------------------------------------------------------
# ● Public Instance Variables
#----------------------------------------------------------------------------
attr_sec_accessor :blur_settings, Blur_Setting
#----------------------------------------------------------------------------
# ● Redirect Listing
#----------------------------------------------------------------------------
redirect_method :change_hue, :hue_change
#-------------------------------------------------------------------------
# ● Define Secondary Listing
#-------------------------------------------------------------------------
define_sec_method(:full_fill) { |color| fill_rect(rect, color) }
#----------------------------------------------------------------------------
# ● Alias Listing
#----------------------------------------------------------------------------
alias_sec_method :invert!, :reversing!
alias_sec_method :grayscale!, :gray_scale!
alias_sec_method :frost, :diffusion
alias_sec_method :frost!, :diffusion!
alias_sec_method :drg_ce_stretch_blt, :stretch_blt
alias_method :drg_bitmap_load, :initialize
#--------------------------------------------------------------------------
# * Object Initialization
#----------------------------------------------------------------------------
def initialize(*args)
if (a = args.flatten).size == 4 && a.all? {|s| s.is_a?(Table)}
bitmap = BitmapDump.read_bitmap_data(*a)
drg_bitmap_load(bitmap.width,bitmap.height)
return blt(0,0,bitmap,rect) && bitmap.dispose
end
drg_bitmap_load(*args)
end
#----------------------------------------------------------------------------
# ● New method: address
#----------------------------------------------------------------------------
unless method_defined?(:address)
def address
@address ||= ( RtlMoveMemory_pi.call(a="\0"*4, __id__*2+16, 4)
RtlMoveMemory_pi.call(a, a.unpack('L')[0]+8, 4)
RtlMoveMemory_pi.call(a, a.unpack('L')[0]+16, 4)
a.unpack('L')[0] )
end
end
#----------------------------------------------------------------------------
# ● New method: export
#----------------------------------------------------------------------------
unless method_defined?(:export)
def export(filename)
file = File.open(filename, 'wb')
size, vxace = width * height * 4, LiTTleDRAgo::RGSS3
case format = File.extname(filename)
when '.bmp'
data = String.new
RtlMoveMemory_pi.call(empty_rString_struct="\0"*16,data.__id__*2,16)
flags = vxace ? 5267461 : 8199
klass = empty_rString_struct.unpack('@4L')[0]
pack = [flags,klass,size,address].pack('L4')
weiss = [size+54,0,54,40,width,height,1,32,0,size,0,0,0,0]
RtlMoveMemory_ip.call(data.__id__*2, pack, 16)
file.write("BM#{weiss.pack('L6S2L6')}")
file.write(data)
RtlMoveMemory_ip.call(data.__id__*2, empty_rString_struct, 16)
when '.png'
write_chunk = Proc.new do |chunk|
file.write([(vxace ? chunk.bytesize : chunk.size)-4].pack('N'))
file.write(chunk)
file.write([Zlib.crc32(chunk)].pack('N'))
end
null_char, w4, i, byte = "\0", width*4, 0, (t_Fx = 0)
RtlMoveMemory_pi.call(data=null_char*size, address, size)
if vxace
data.force_encoding('ASCII-8BIT')
(0).step(size-4, 4) do |i|
Graphics.update if (t_Fx += 1) % 10000 == 0
byte = data.getbyte(i)
data.setbyte(i, data.getbyte(i+=2))
data.setbyte(i, byte)
end
else
(0).step(size-4, 4) do |i|
Graphics.update if (t_Fx += 1) % 10000 == 0
data[i,3] = data[i,3].reverse!
end
end
deflate = Zlib::Deflate.new(9)
(size-w4).step(0, -w4) {|i| deflate << null_char << data[i,w4]}
file.write("\211PNG\r\n\32\n")
write_chunk.call("IHDR#{[width,height,8,6,0,0,0].pack('N2C5')}")
write_chunk.call("IDAT#{deflate.finish}")
write_chunk.call('IEND')
deflate.close
when ''
script_report("Error: Export Bitmap Failed\n"+
"Extension '#{filename}' is missing.")
else
script_report("Error: Export Bitmap Failed\n"+
"Extension '#{format}' is not supported.")
end
file.close
end
end
#----------------------------------------------------------------------------
# ● New method: blt_cache
#----------------------------------------------------------------------------
unless method_defined?(:blt_cache)
def blt_cache(x, y, width, height, text, align, edging)
cache_bitmap = LiTTleDRAgo.cache.draw_text(
width, height, text, self.font.name, self.font.size,
self.font.bold, self.font.italic, self.font.color, edging
)
x_plus = uncache_align_exe(width, text, align)
blt(x + x_plus , y , cache_bitmap, Rect.new(0, 0, width, height))
end
end
#----------------------------------------------------------------------------
# ● New method: uncache_align_exe
#----------------------------------------------------------------------------
unless method_defined?(:uncache_align_exe)
def uncache_align_exe(width, text, align)
recter = self.text_size(text)
case align
when 0 then x_index = 0
when 1 then x_index = (width / 2) - recter.width / 2
when 2 then x_index = width - recter.width
else
raise "Text Cache : align is wrong"
end
return x_index
end
end
#----------------------------------------------------------------------------
# ● New method: draw_cache_text
#----------------------------------------------------------------------------
unless method_defined?(:draw_cache_text)
def draw_cache_text(x, y, width, height, text, align = 0)
blt_cache(x, y, width, height, text, align, false)
end
end
#----------------------------------------------------------------------------
# ● New method: draw_edging_cache_text
#----------------------------------------------------------------------------
unless method_defined?(:draw_edging_cache_text)
def draw_edging_cache_text(x, y, width, height, text, align = 0)
blt_cache(x, y, width, height, text, align, true)
end
end
#----------------------------------------------------------------------------
# ● New method: draw_easy_cache_text
#----------------------------------------------------------------------------
unless method_defined?(:draw_easy_cache_text)
def draw_easy_cache_text(x, y, text)
t_rect = text_size(text)
blt_cache(x, y, t_rect.width, t_rect.height, text, 0, false)
end
end
#----------------------------------------------------------------------------
# ● New method: draw_easy_edging_cache_text
#----------------------------------------------------------------------------
unless method_defined?(:draw_easy_edging_cache_text)
def draw_easy_edging_cache_text(x, y, text)
t_rect = text_size(text)
blt_cache(x, y, t_rect.width, t_rect.height, text, 0, true)
end
end
#--------------------------------------------------------------------------
# * New method: change_color
#--------------------------------------------------------------------------
unless method_defined?(:change_color)
def change_color(color, enabled = true)
font.color = color
font.color.alpha = translucent_alpha unless enabled
end
end
#--------------------------------------------------------------------------
# ● New method: draw_picture
#--------------------------------------------------------------------------
unless method_defined?(:draw_picture)
def draw_picture(file_name, x, y, opacity = 255)
bitmap = LiTTleDRAgo.cache.picture(file_name)
cw = bitmap.width
ch = bitmap.height
src_rect = Rect.new(0, 0, cw, ch)
blt(x, y, bitmap, src_rect, opacity)
end
end
#--------------------------------------------------------------------------
# ● New method: draw_icon
#--------------------------------------------------------------------------
unless method_defined?(:draw_icon)
def draw_icon(file_name, x, y, enabled = true)
if file_name.is_a?(Numeric)
bitmap = LiTTleDRAgo.cache.system("Iconset")
src_rect = Rect.new(file_name % 16 * 24, file_name / 16 * 24, 24, 24)
blt(x, y, bitmap, src_rect, enabled ? 255 : 160)
elsif file_name.is_a?(String)
bitmap = LiTTleDRAgo.cache.icon(file_name)
src_rect = Rect.new(0, 0, 24, 24)
blt(x, y, bitmap, bitmap.rect, enabled ? 255 : 160)
end
end
end
#--------------------------------------------------------------------------
# ● New method: draw_battler
#--------------------------------------------------------------------------
unless method_defined?(:draw_battler)
def draw_battler(file_name, x, y, hue = 0, enabled = true)
bitmap = LiTTleDRAgo.cache.battler(file_name, hue)
cw = bitmap.width
ch = bitmap.height
src_rect = Rect.new(0, 0, cw, ch)
blt(x, y, bitmap, src_rect, enabled ? 255 : 160)
end
end
#--------------------------------------------------------------------------
# ● New method: draw_bar
#--------------------------------------------------------------------------
unless method_defined?(:draw_bar)
def draw_bar(x, y, current, file)
bitmap = LiTTleDRAgo.cache.picture(file)
cw = bitmap.width * current / 100
ch = bitmap.height
src_rect = Rect.new(0, 0, cw, ch)
blt(x, y, bitmap, src_rect)
end
end
#--------------------------------------------------------------------------
# ● New method: draw_edging_text
#--------------------------------------------------------------------------
unless method_defined?(:draw_edging_text)
def draw_edging_text(x, y, width, height, text, align=0)
old_color = font.color.dup
font.color = Color.new(0, 0, 0)
draw_text(x-1, y-1, width, height, text, align)
draw_text(x-1, y+1, width, height, text, align)
draw_text(x+1, y-1, width, height, text, align)
draw_text(x+1, y+1, width, height, text, align)
font.color = old_color
draw_text(x, y, width, height, text, align)
end
end
#--------------------------------------------------------------------------
# ● New method: draw_enter_text
#--------------------------------------------------------------------------
unless method_defined?(:draw_enter_text)
def draw_enter_text(x, y, width, height, text, align=0)
rect = text_size(text)
info_box = text.split(/\n/)
info_box.size.times do |i|
draw_text( x, y+i*rect.height, width, height, info_box[i], align)
break if (y+i*rect.height) > self.height
end
end
end
#--------------------------------------------------------------------------
# ● New method: draw_enter_edging_text
#--------------------------------------------------------------------------
unless method_defined?(:draw_enter_edging_text)
def draw_enter_edging_text(x, y, width, height, text, align=0)
rect = text_size(text)
info_box = text.split(/\n/)
info_box.size.times do |i|
draw_edging_text( x, y+i*rect.height,width,height,info_box[i],align)
break if (y+i*rect.height) > self.height
end
end
end
#--------------------------------------------------------------------------
# ● New method: draw_easy_text
#--------------------------------------------------------------------------
unless method_defined?(:draw_easy_text)
def draw_easy_text(x, y, text)
rect = text_size(text)
draw_text(x, y, rect.width + rect.height/2, rect.height, text)
end
end
#--------------------------------------------------------------------------
# ● New method: draw_auto_text
#--------------------------------------------------------------------------
unless method_defined?(:draw_auto_text)
def draw_auto_text(x, y, width, height, text)
ini_x = 0
law = 0
text_box = []
text_box[law] = []
otxto = text.split(//)
otxto.size.times do |i|
text_rect = text_size(otxto[i])
if (x + ini_x + text_rect.width) < width
ini_x += text_rect.width
else
law += 1
ini_x = text_rect.width
text_box[law] = []
end
text_box[law].push(otxto[i])
end
for l in 0..law
ini_x = 0
text_box[l].size.times do |i|
rect = text_size(text_box[l][i])
draw_text(x + ini_x, y+l*height, rect.width, height, text_box[l][i])
ini_x += rect.width
end
end
end
end
#-------------------------------------------------------------------------
# ● New method: erase
#-------------------------------------------------------------------------
unless method_defined?(:erase)
def erase(*a)
rect = nil
if a.at(0).is_a?(Rect) then rect = a.at(0)
elsif a.size == 4 then rect = Rect.new(*a)
elsif a.size == 0 then rect = Rect.new(0,0,width,height)
end
fill_rect(rect.x, rect.y, rect.width, rect.height, Color.erase) if rect
end
end
#-------------------------------------------------------------------------
# ● New method: stretch
#-------------------------------------------------------------------------
unless method_defined?(:stretch)
def stretch(width, height)
dummy = Bitmap.new(width, height)
dummy.stretch_blt(*[dummy.rect, self, self.rect])
dummy
end
end
#-------------------------------------------------------------------------
# ● New method: crop
#-------------------------------------------------------------------------
unless method_defined?(:crop)
def crop(*a)
return unless a.size == 1 or a.size == 4
rect = rect.at(0) if a.size == 1 && a.at(0).is_a?(Rect)
rect = Rect.new(*a) if a.size == 4
cropped = Bitmap.new([rect.width,width-rect.x].min,
[rect.height,height-rect.y].min)
cropped.blt(0,0,self,rect)
cropped
end
end
#-------------------------------------------------------------------------
# ● Aliased method: stretch_blt
#-------------------------------------------------------------------------
def stretch_blt(*a)
if respond_to?(:stretch_blend_blt)
a = [a[0..2],0,1,a.at(3)||255].flatten
stretch_blend_blt(*a)
else
drg_ce_stretch_blt(*a)
end
end
#-------------------------------------------------------------------------
# ● Aliased method: hue_change
#-------------------------------------------------------------------------
define_post_alias(:hue_change) { self }
#--------------------------------------------------------------------------
# ● New method: invert, etc
#--------------------------------------------------------------------------
[:invert, :brighten, :darken, :grayscale, :pixelate, :frost, :flip_horizontal,
:flip_vertical, :rotate90, :rotate180, :rotate270].each do |meth|
define_sec_method(meth) do |*args|
bitmap = self.clone
bitmap.send(:"#{meth}!",*args)
return bitmap
end
end
#-------------------------------------------------------------------------
# ● New method: flip_horizontal!
#-------------------------------------------------------------------------
define_sec_method(:flip_horizontal!) do
flipped = Bitmap.new(width, height)
fliprect = Rect.new(width,0,-width,height)
flipped.blt(0,0, self,fliprect)
(clear || 0) && blt(0,0,flipped,rect)
flipped.dispose
end
#-------------------------------------------------------------------------
# ● New method: flip_vertical!
#-------------------------------------------------------------------------
define_sec_method(:flip_vertical!) do
flipped = Bitmap.new(width, height)
fliprect = Rect.new(0,height,width,-height)
flipped.blt(0,0, self,fliprect)
(clear || 0) && blt(0,0,flipped,rect)
flipped.dispose
end
#-------------------------------------------------------------------------
# ● New method: rotate90! (clockwise)
#-------------------------------------------------------------------------
define_sec_method(:rotate90!) do
copy = self.clone
(t_Fx = width).times do |i|
height.times do |j|
Graphics.update if (t_Fx += 1) % 10000 == 0
a = (clockwise = true) ? [width - i - 1, j] : [i, height - j - 1]
self.set_pixel(a[0],a[1], copy.get_pixel(j, i))
end
end
copy.dispose
end
#-------------------------------------------------------------------------
# ● New method: rotate180!
#-------------------------------------------------------------------------
define_sec_method(:rotate180!) do
flip_vertical!
flip_horizontal!
end
#-------------------------------------------------------------------------
# ● New method: rotate270!
#-------------------------------------------------------------------------
define_sec_method(:rotate270!) do
rotate90!
rotate180!
end
#----------------------------------------------------------------------------
# ● New method: invert!
#----------------------------------------------------------------------------
unless method_defined?(:invert!)
def invert!
(t_Fx = width).times do |i|
height.times do |j|
color = get_pixel(i, j)
Graphics.update if (t_Fx += 1) % 10000 == 0
set_pixel(i, j, color.invert) if color.alpha > 0
end
end
end
end
#--------------------------------------------------------------------------
# * New method: brighten!
#--------------------------------------------------------------------------
unless method_defined?(:brighten!)
def brighten!(amount = 10)
(t_Fx = width).times do |w|
height.times do |h|
color = get_pixel(w, h)
Graphics.update if (t_Fx += 1) % 10000 == 0
set_pixel(w, h, Color.new([color.red + amount, 255].min,
[color.green + amount, 255].min,
[color.blue + amount, 255].min,
color.alpha)) if color.alpha > 0
end
end
end
end
#--------------------------------------------------------------------------
# * New method: darken!
#--------------------------------------------------------------------------
unless method_defined?(:darken!)
def darken!(amount = 10)
(t_Fx = width).times do |w|
height.times do |h|
color = get_pixel(w, h)
Graphics.update if (t_Fx += 1) % 10000 == 0
set_pixel(w, h, Color.new([color.red - amount, 0].max,
[color.green - amount, 0].max,
[color.blue - amount, 0].max,
color.alpha)) if color.alpha > 0
end
end
end
end
#--------------------------------------------------------------------------
# * New method: grayscale!
# NOTE: calling this method repeatedly has no effect on the bitmap, but will
# still waste processing power. Do not call it repeatedly.
#--------------------------------------------------------------------------
unless method_defined?(:grayscale!)
def grayscale!
(t_Fx = width).times do |w|
height.times do |h|
color = get_pixel(w, h)
if (a = color.alpha) > 0
Graphics.update if (t_Fx += 1) % 10000 == 0
num = (color.red + color.green + color.blue) / 3
set_pixel(w, h, Color.new(num, num, num, a))
end
end
end
end
end
#--------------------------------------------------------------------------
# * New method: drg_pixelate! (0.2 second)
# NOTE: Pixelateing bitmaps to a larger pixel size is less process consuming.
# for best results, don't pixelate to numbers below four.
# This works much better for solid images, due to bugs.
#--------------------------------------------------------------------------
unless method_defined?(:drg_pixelate!)
def drg_pixelate!(size = 10)
return self if size <= (t_Fx = 1)
c = lambda {|a,b| (a / b**2) * Math.sqrt(b) }
for w in 0..((width - 1) / size)
w *= size
for h in 0..((height - 1) / size)
h *= size
r, g, b, a = 0, 0, 0, 0
size.times do |i|
color = get_pixel(w, h)
r += color.red
g += color.green
b += color.blue
a += color.alpha
color = get_pixel(w + i, h)
r += color.red
g += color.green
b += color.blue
a += color.alpha
color = get_pixel(w, h + i)
r += color.red
g += color.green
b += color.blue
a += color.alpha
end
Graphics.update if (t_Fx += 1) % 10000 == 0
fill_rect(w, h, size, size, Color.new(c.call(r,size),c.call(g,size),
c.call(b,size),c.call(a,size)))
end
end
end
end
#--------------------------------------------------------------------------
# * New method: pixelate!
#--------------------------------------------------------------------------
unless method_defined?(:pixelate!)
def pixelate!(size = 10)
return mosaic!(size,size) if respond_to?(:mosaic!)
return drg_pixelate!(size)
end
end
#--------------------------------------------------------------------------
# * New method: drg_frost! (5 second)
# NOTE: Frosting a bitmap randomly scatters its pixels. As such, Consistant
# results are impossible to get.
# Frosting a bitmap beyond eight won't result in a more scattered image
#--------------------------------------------------------------------------
unless method_defined?(:drg_frost!)
def drg_frost!(noise = 10)
for pass in 1..noise
(t_Fx = width).times do |w|
height.times do |h|
Graphics.update if (t_Fx += 1) % 10000 == 0
set_pixel(w, h, get_pixel(w + rand(3) - 1, h + rand(3) - 1))
end
end
end
end
end
#-------------------------------------------------------------------------
# ● New method: bltapiinit
#-------------------------------------------------------------------------
unless method_defined?(:bltapiinit)
def bltapiinit
info = [40,width,height,1,32,0,0,0,0,0,0].pack('LllSSLLllLL')
hWndDC = LiTTleDRAgo.getdc.call(LiTTleDRAgo.hwnd)
hMemDC = LiTTleDRAgo.ccdc.call(hWndDC)
hMemBM = LiTTleDRAgo.ccbitmap.call(hWndDC, width, height)
LiTTleDRAgo.releasedc.call(LiTTleDRAgo.hwnd, hWndDC)
LiTTleDRAgo.selectobject.call(hMemDC, hMemBM)
LiTTleDRAgo.setdibits.call(hMemDC, hMemBM, 0, height, address, info, 0)
return hMemDC, hMemBM, info
end
end
#-------------------------------------------------------------------------
# ● New method: bit_blt
#-------------------------------------------------------------------------
unless method_defined?(:bit_blt)
def bit_blt(x, y, src_bmp, src_rect, rastor_operation = 0xCC0020)
hDC1, hBM1, info = *self.bltapiinit
hDC2, hBM2 = *src_bmp.bltapiinit
LiTTleDRAgo.bitblt.call(hDC1, x, y, src_rect.width, src_rect.height,
hDC2, src_rect.x, src_rect.y, rastor_operation)
LiTTleDRAgo.getdibits.call(hDC1, hBM1, 0, height, address, info, 0)
LiTTleDRAgo.deleteobject.call(hBM1)
LiTTleDRAgo.deleteobject.call(hDC1)
LiTTleDRAgo.deleteobject.call(hBM2)
LiTTleDRAgo.deleteobject.call(hDC2)
end
end
#-------------------------------------------------------------------------
# ● New method: crop_blt
#-------------------------------------------------------------------------
unless method_defined?(:crop_blt)
def crop_blt(x, y, width, height, bitmap, dir = 1, align = 1, opacity = 255)
w, h = bitmap.width, bitmap.height
if w < width and h < height
x += (width - w) / 2 if align == 1
x += width - w if align == 2
return full_blt(x, y, bitmap, opacity)
end
i, j = dir % 3, dir / 3
crop_x, crop_y = 0, 0
crop_x = (w - width) / 2 if i == 1
crop_x = w - width if i == 2
crop_y = (h - height) / 2 if j == 1
crop_y = h - height if j == 2
blt(x, y, bitmap, Rect.new(crop_x, crop_y, width, height), opacity)
end
end
#-------------------------------------------------------------------------
# ● New method: fit_blt
#-------------------------------------------------------------------------
unless method_defined?(:fit_blt)
def fit_blt(x, y, width, height, bitmap, opacity = 255, align = 1)
w, h = bitmap.width, bitmap.height
if w > width or h > height
conversion = w / h.to_f
zoom_x, zoom_y = width * conversion, height if conversion <= 1
zoom_x, zoom_y = width, height / conversion unless conversion <= 1
x += (width - zoom_x) / 2 if align == 1
x += width - zoom_x if align == 2
dest_rect = Rect.new(x, y, zoom_x, zoom_y)
stretch_blt(dest_rect, bitmap, bitmap.rect, opacity)
else
x += (width - w) / 2 if align == 1
x += width - w if align == 2
full_blt(x, y, bitmap, opacity)
end
end
end
#-------------------------------------------------------------------------
# ● New method: full_blt
#-------------------------------------------------------------------------
unless method_defined?(:full_blt)
def full_blt(x, y, bitmap, opacity = 255)
blt(x, y, bitmap, bitmap.rect, opacity)
end
end
#-------------------------------------------------------------------------
# ● New method: scale_blt
#-------------------------------------------------------------------------
unless method_defined?(:scale_blt)
def scale_blt(dest_rect, src_bitmap, src_rect = src_bitmap.rect, o = 255)
w, h = src_rect.width, src_rect.height
scale = [w / dest_rect.width.to_f, h / dest_rect.height.to_f].max
ow, oh = (w / scale).to_i, (h / scale).to_i
ox, oy = (dest_rect.width - ow) / 2, (dest_rect.height - oh) / 2
stretch_blt(Rect.new(ox + dest_rect.x, oy + dest_rect.y, ow, oh),
src_bitmap, src_rect, o)
end
end
#-------------------------------------------------------------------------
# ● New method: frames_flip_horizontal
#-------------------------------------------------------------------------
unless method_defined?(:frames_flip_horizontal)
def frames_flip_horizontal(frames)
frame_width = width / frames
frame_bitmap = Bitmap.new(frame_width, height)
rect = Rect.new(0, 0, frame_width, height)
frames.times do |i|
frame_bitmap.clear
rect.x = (x = i * frame_width)
frame_bitmap.blt(0, 0, self, rect)
frame_bitmap.flip_horizontal!
blt(x, 0, frame_bitmap, frame_bitmap.rect)
end
frame_bitmap.dispose
end
end
#-------------------------------------------------------------------------
# ● New method: frames_flip_vertical
#-------------------------------------------------------------------------
unless method_defined?(:frames_flip_vertical)
def frames_flip_vertical(frames)
frame_height = height / frames
frame_bitmap = Bitmap.new(width, frame_height)
rect = Rect.new(0, 0, width, frame_height)
frames.times do |i|
frame_bitmap.clear
rect.y = (y = i * frame_height)
frame_bitmap.blt(0, 0, self, rect)
frame_bitmap.flip_vertical!
blt(0, y, frame_bitmap, frame_bitmap.rect)
end
frame_bitmap.dispose
end
end
#-------------------------------------------------------------------------
# ● New method: blur_area
#-------------------------------------------------------------------------
unless method_defined?(:blur_area)
def blur_area(settings = {})
blur_settings.each do |default, setting|
settings[default] = setting unless settings.has_key?(default)
end
keys = settings.keys
rect_defined = keys.include?('rect')
rect_p_defined = keys.include?('x') && keys.include?('y') &&
keys.include?('w') && keys.include?('h')
if rect_defined
rect = settings['rect']
x, y, w, h = rect.x, rect.y, rect.width, rect.height
elsif rect_p_defined
x, y, w, h = settings['x'], settings['y'], settings['w'], settings['h']
else
x, y, w, h = 0, 0, self.width, self.height
end
dummy = self.dup
spacing = settings['spacing']
opacity = settings['opacity']
settings['offset'].times do |i|
src_rects = []
src_rects << Rect.new(x + i * spacing, y + i * spacing, w, h)
src_rects << Rect.new(x - i * spacing, y + i * spacing, w, h)
src_rects << Rect.new(x + i * spacing, y - i * spacing, w, h)
src_rects << Rect.new(x - i * spacing, y - i * spacing, w, h)
o = Integer(opacity * (settings['offset'] - i) / (settings['offset']))
src_rects.each { |src_rect| blt(x, y, dummy, src_rect, o)}
end
dummy.dispose
self
end
end
#-------------------------------------------------------------------------
# ● New method: sub_bitmap_blend
#-------------------------------------------------------------------------
unless method_defined?(:sub_bitmap_blend)
def sub_bitmap_blend(x = 0, y = 0, bitmap = self, src_rect = bitmap.rect)
src_rect.width.times do |i|
src_rect.height.times do |j|
c1 = get_pixel(x + i, y + j)
c2 = bitmap.get_pixel(src_rect.x + i, src_rect.y + j)
nc = Color.new(c1.red-c2.red, c1.green-c2.green, c1.blue-c2.blue)
set_pixel(x + i, y + j, nc) if c2.alpha > 0
end
end
end
end
#-------------------------------------------------------------------------
# ● New method: add_bitmap_blend
#-------------------------------------------------------------------------
unless method_defined?(:add_bitmap_blend)
def add_bitmap_blend(x = 0, y = 0, bitmap = self, src_rect = bitmap.rect)
src_rect.width.times do |i|
src_rect.height.times do |j|
c1 = get_pixel(x + i, y + j)
c2 = bitmap.get_pixel(src_rect.x + i, src_rect.y + j)
nc = Color.new(c1.red+c2.red, c1.green+c2.green, c1.blue+c2.blue)
set_pixel(x + i, y + j, nc) if c2.alpha > 0
end
end
end
end
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias_sec_method :frost!, :drg_frost!
alias_sec_method :blur, :blur_area
alias_sec_method :entire_fill, :full_fill
#--------------------------------------------------------------------------
# * Replicated method: gradient_fill_rect
#--------------------------------------------------------------------------
unless method_defined?(:gradient_fill_rect)
def gradient_fill_rect(*a)
if a.first.is_a?(Rect)
x, y, width, height = a[0].x, a[0].y, a[0].width, a[0].height
color1 = a.at(1).dup
color2 = a.at(2)
vertical = a.at(3)
else
x, y, width, height = a[0..3]
color1 = a.at(4).dup
color2 = a.at(5)
vertical = a.at(6)
end
dr = color2.red - color1.red
dg = color2.green - color1.green
db = color2.blue - color1.blue
da = color2.alpha - color1.alpha
start_rgba = [color1.red, color1.green, color1.blue, color1.alpha]
if vertical
dr, dg, db, da = dr / height, dg / height, db / height, da / height
for i in (y.round...(y + height).round)
fill_rect(x, i, width, 1, color1)
start_rgba[0] = [start_rgba.at(0) + dr, 0].max.round
start_rgba[1] = [start_rgba.at(1) + dg, 0].max.round
start_rgba[2] = [start_rgba.at(2) + db, 0].max.round
start_rgba[3] = [start_rgba.at(3) + da, 0].max.round
color1.set(*start_rgba)
end
else
dr, dg, db, da = dr / width, dg / width, db / width, da / width
for i in (x.round...(x + width).round)
fill_rect(i, y, 1, height, color1)
start_rgba[0] = [start_rgba.at(0) + dr, 0].max.round
start_rgba[1] = [start_rgba.at(1) + dg, 0].max.round
start_rgba[2] = [start_rgba.at(2) + db, 0].max.round
start_rgba[3] = [start_rgba.at(3) + da, 0].max.round
color1.set(*start_rgba)
end
end
end
end
end
#==============================================================================
# ** String
#------------------------------------------------------------------------------
#
#==============================================================================
class String
#-------------------------------------------------------------------------
# ● New method: get_int
#-------------------------------------------------------------------------
unless method_defined?(:get_int)
def get_int
m = self.scan(/([-]?\d+)/i).flatten
return m.join.to_i
end
end
#-------------------------------------------------------------------------
# ● New method: get_ints
#-------------------------------------------------------------------------
unless method_defined?(:get_ints)
def get_ints
array = self.scan(/([-]?\d+)/i).flatten.relay(:i)
return array
end
end
#-------------------------------------------------------------------------
# ● New method: encrypt
#-------------------------------------------------------------------------
unless method_defined?(:encrypt)
def encrypt(encryption_string = 'encrypt')
encryption_bytes = []
encryption_string.each_byte {|c| encryption_bytes << c}
string = ''
self.size.times do |i|
byte = self[i] * encryption_bytes[i % encryption_bytes.size]
base, mod = byte / 255, byte % 255
string += base.chr + mod.chr
end
return string
end
end
#-------------------------------------------------------------------------
# ● New method: encrypt!
#-------------------------------------------------------------------------
unless method_defined?(:encrypt!)
def encrypt!(encryption_string = 'encrypt')
replace(encrypt(encryption_string))
end
end
#-------------------------------------------------------------------------
# ● New method: decrypt
#-------------------------------------------------------------------------
unless method_defined?(:decrypt)
def decrypt(encryption_string = 'encrypt')
encryption_bytes = []
encryption_string.each_byte {|c| encryption_bytes << c}
string = ''
(self.size / 2).times do |i|
b, m = self[i * 2] * 255, self[i * 2 + 1]
string += ((b + m) / encryption_bytes[i % encryption_bytes.size]).chr
end
return string
end
end
#-------------------------------------------------------------------------
# ● New method: decrypt!
#-------------------------------------------------------------------------
unless method_defined?(:decrypt!)
def decrypt!(encryption_string = 'encrypt')
replace(decrypt(encryption_string))
end
end
#-------------------------------------------------------------------------
# ● New method: clear, words, characters
#-------------------------------------------------------------------------
define_sec_method(:clear) { replace('') }
define_sec_method(:words) { split(' ') }
define_sec_method(:characters) { split('') }
define_sec_method(:last) { characters.last }
define_sec_method(:first) { characters.first }
end
#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
# An interpreter for executing event commands. This class is used within the
# Game_Map, Game_Troop, and Game_Event classes.
#==============================================================================
Klass = LiTTleDRAgo::VX ? Game_Interpreter : Interpreter
class Klass
#--------------------------------------------------------------------------
# * Constant
#--------------------------------------------------------------------------
SCRIPT_WAIT_RESULTS = [:wait, FalseClass]
#--------------------------------------------------------------------------
# ● Redirect Listing
#--------------------------------------------------------------------------
redirect_method :picture_sprite, '$game_map.picture_sprite'
#--------------------------------------------------------------------------
# ● New method: random_teleport
#--------------------------------------------------------------------------
unless method_defined?(:random_teleport)
def random_teleport(id = 0)
character = id.is_a?(Game_Character) ? id : get_character(id)
character.random_teleport if character.is_a?(Game_Character)
end
end
#--------------------------------------------------------------------------
# ● Redefined method: same_map?, next_event_code
#--------------------------------------------------------------------------
define_sec_method(:same_map?) { @map_id == $game_map.map_id }
define_sec_method(:next_event_code) { @list[@index + 1].code }
#--------------------------------------------------------------------------
# * Overwriten method: command_355
#--------------------------------------------------------------------------
def command_355
script = @list[index = @index].parameters[0] + "\n"
while [655, 355].include?(next_event_code) do
script += @list[@index+=1].parameters[0] + "\n"
end
wait = SCRIPT_WAIT_RESULTS.include?(eval(script)) && LiTTleDRAgo::XP
return wait ? !(@index = index) : true
end
end
#==============================================================================
# ** Sprite
#------------------------------------------------------------------------------
# A sprite class for bitmap processing.
#==============================================================================
class Sprite
#---------------------------------------------------------------------------
# * Alias Listing
#---------------------------------------------------------------------------
alias_sec_method(:angle_fix_alias, :"angle=")
alias_sec_method(:drg_core_dispose,:"dispose")
alias_sec_method(:set_x_alias, :"x=")
alias_sec_method(:set_y_alias, :"y=")
alias_sec_method(:get_x_alias, :"x")
alias_sec_method(:get_y_alias, :"y")
#---------------------------------------------------------------------------
# * New method: method_missing
#---------------------------------------------------------------------------
def method_missing(val,*a,&b)
return bitmap.send(val.to_s,*a,&b) if bitmap.respond_to?(val.to_sym)
text = "Undefined method #{val} for #{self.inspect}"
raise(NoMethodError, text, caller(1))
end
#---------------------------------------------------------------------------
# * Aliased method: x=, y=
#---------------------------------------------------------------------------
define_method(:x=) {|amt| set_x_alias((@intfloat_x = amt).to_i) }
define_method(:y=) {|amt| set_y_alias((@intfloat_y = amt).to_i) }
define_method(:x) { @intfloat_x ||= get_x_alias }
define_method(:y) { @intfloat_y ||= get_y_alias }
define_method(:dispose) { disposed? || drg_core_dispose }
define_method(:rotate_correction) { self.ox,self.oy = width/2, height/2 }
#---------------------------------------------------------------------------
# * Aliased method: angle=
#---------------------------------------------------------------------------
def angle=(v)
return if @angle == v
sign = (v % 360 == 180 || v % 180 == 90) ? 1.00001 : 1
angle_fix_alias((@angle = v) * sign)
end
#--------------------------------------------------------------------------
# ● Redefined method: width, height
#--------------------------------------------------------------------------
define_sec_method(:width) { src_rect.width }
define_sec_method(:height) { src_rect.height }
#--------------------------------------------------------------------------
# ● Overwriten method: dup
#--------------------------------------------------------------------------
def dup
sprite = self.class.new(self.viewport)
sprite.bitmap = self.bitmap.clone
sprite.zoom_x, sprite.zoom_y = self.zoom_x, self.zoom_y
sprite.x, sprite.y = self.x, self.y
sprite.ox, sprite.oy = self.ox, self.oy
sprite.color, sprite.tone = self.color.dup, self.tone.dup
sprite.src_rect,sprite.angle = self.src_rect, self.angle
return sprite
end
#--------------------------------------------------------------------------
# ● Overwriten method: clone
#--------------------------------------------------------------------------
def clone
(sprite = self.dup) && instance_variables.each do |var|
temp = instance_variable_get("#{var}")
sprite.instance_variable_set("#{var}",temp) rescue nil
end
(frozen? && sprite.freeze)
return sprite
end
#--------------------------------------------------------------------------
# ● New method: scale
#--------------------------------------------------------------------------
unless method_defined?(:scale)
def scale(w, h)
tmp = self.bitmap.clone
self.bitmap = Bitmap.new(w, h)
self.bitmap.stretch_blt(Rect.new(0, 0, w, h), tmp, tmp.rect)
tmp.dispose
end
end
#--------------------------------------------------------------------------
# ● New method: in_rect?
#--------------------------------------------------------------------------
unless method_defined?(:in_rect?)
def in_rect?(*rect)
if rect.size == 1
x, y, w, h = rect[0].x, rect[0].y, rect[0].width, rect[0].height
return self.x.between?(x, x + w) && self.y.between?(y, y + h)
elsif rect.size == 4
x, y, w, h = rect
return self.x.between?(x, x + w) && self.y.between?(y, y + h)
end
return false
end
end
end
#==============================================================================
# ** Scheduler
#------------------------------------------------------------------------------
# This class allows to schedule a proc or method call a given amount of frames
# into the future with any amount of arguments
#==============================================================================
unless defined?(Scheduler)
class Scheduler
#==========================================================================
# ** Order
#--------------------------------------------------------------------------
# An order is a proc, method or something else which has 'call' as a
# method, and the arguments to pass along.
#==========================================================================
unless method_defined?(:update)
Order = Struct.new(:callable, :arguments)
class Order
#----------------------------------------------------------------------
# * New Methods: call
#----------------------------------------------------------------------
define_method(:call) { callable.call(*arguments) }
end
#========================================================================
# ** RecurringOrder
#------------------------------------------------------------------------
# An order which is recurring every specified amount of time until
# FalseClass is returned from the call.
# Note that arguments remain the same for each call
#========================================================================
RecurringOrder = Struct.new(:callable, :arguments, :frames)
class RecurringOrder
#----------------------------------------------------------------------
# * New Methods: call
#----------------------------------------------------------------------
def call
result = callable.call(*arguments)
unless result == FalseClass
Scheduler.schedule_recurring(frames, frames, callable, *arguments)
end
end
end
#========================================================================
# ** Mapping
#------------------------------------------------------------------------
# Maps an index to an array. Values can be added to these value.
# Each array starts empty.
#========================================================================
class Mapping
#----------------------------------------------------------------------
# * New method: add, get, empty
#----------------------------------------------------------------------
define_method(:add) { |i, v| ((@mapping ||= {})[i] ||=[]) << v }
define_method(:get) { |i| ((@mapping ||= {})[i] || []) }
define_method(:empty) { |i| (@mapping ||= {}).delete(i) }
end
#------------------------------------------------------------------------
# * New method: schedule
#------------------------------------------------------------------------
def schedule(frames, callable, *arguments)
order = Order.new(callable, arguments)
(@mapping ||= Mapping.new).add(frames + (@tick||=0), order)
end
#------------------------------------------------------------------------
# * New method: schedule_recurring
#------------------------------------------------------------------------
def schedule_recurring(frames, frames_to_wait, callable, *arguments)
order = RecurringOrder.new(callable, arguments, frames_to_wait)
(@mapping ||= Mapping.new).add(frames + (@tick||=0), order)
end
#------------------------------------------------------------------------
# * New method: update
#------------------------------------------------------------------------
def update
orders = (@mapping ||= Mapping.new).get((@tick||=0))
@mapping.empty(@tick)
orders.each {|s| s.call }
@tick += 1
end
#------------------------------------------------------------------------
# * Self
#------------------------------------------------------------------------
@@instance = self.new
class << self
define_method(:instance) { @@instance }
redirect_method :schedule_recurring, 'instance.schedule_recurring'
redirect_method :schedule, 'instance.schedule'
redirect_method :update, 'instance.update'
end
end
end
Graphics.auto_update.push([Scheduler,:update])
end
#==============================================================================
# ** Dir
#------------------------------------------------------------------------------
#
#==============================================================================
class << Dir
#--------------------------------------------------------------------------
# ● New method: make_dir
#--------------------------------------------------------------------------
def make_dir(path)
(dir = path.split("/")).size.times do |i|
next if dir == "."
Dir.mkdir(dir[0..i].join("/")) rescue nil
end
end
#--------------------------------------------------------------------------
# ● New method: files_with_extension
#--------------------------------------------------------------------------
def files_with_extension(directory, extension)
entries(directory).select{|file| File.extname(file) == extension}
end
end
#==============================================================================
# ** BitmapDump
#------------------------------------------------------------------------------
#
#==============================================================================
module BitmapDump; end
class << BitmapDump
#--------------------------------------------------------------------------
# ● New method: self.bitmap_data
#--------------------------------------------------------------------------
unless method_defined?(:bitmap_data)
def bitmap_data(bitmap)
red = Table.new(bitmap.width, bitmap.height)
green, blue, alpha = red.clone, red.clone, red.clone
bitmap.width.times do |i|
bitmap.height.times do |j|
color = bitmap.get_pixel(i, j)
red[i, j], green[i, j] = color.red, color.green
blue[i, j], alpha[i, j] = color.blue, color.alpha
end
end
return [red, green, blue, alpha]
end
end
#--------------------------------------------------------------------------
# ● New method: self.read_bitmap_data
#--------------------------------------------------------------------------
unless method_defined?(:read_bitmap_data)
def read_bitmap_data(red, green, blue, alpha)
bitmap = Bitmap.new(red.xsize, red.ysize)
bitmap.width.times do |i|
bitmap.height.times do |j|
color_table = [red[i, j], green[i, j], blue[i, j], alpha[i, j]]
bitmap.set_pixel(i, j, Color.new(*color_table))
end
end
return bitmap
end
end
#--------------------------------------------------------------------------
# ● New method: self.save_bitmap
#--------------------------------------------------------------------------
unless method_defined?(:save_bitmap)
def save_bitmap(bitmap, filename, folder = '')
bitmap_data = bitmap_data(bitmap)
if folder && folder != ''
Dir.make_dir(folder) unless FileTest.directory?(folder)
filename = "#{folder}/#{filename}"
end
filename = filename.gsub("\\","/").gsub("//","/")
file = File.open(filename,'wb')
Marshal.dump(bitmap_data, file)
file.close
end
end
#--------------------------------------------------------------------------
# ● New method: self.load_bitmap
#--------------------------------------------------------------------------
unless method_defined?(:load_bitmap)
def load_bitmap(filename, folder = '')
if folder && folder != ''
Dir.make_dir(folder) unless FileTest.directory?(folder)
filename = "#{folder}/#{filename}"
end
filename = filename.gsub("\\","/").gsub("//","/")
file = File.open(filename,"rb")
colors = Marshal.load(file)
file.close
bitmap = read_bitmap_data(colors)
return bitmap
end
end
end