BaseScript: Enhanced Image Sprites

#encoding:utf-8

=begin
*******************************************************************************************

   ＊ BaseScript: Enhanced Image Sprites ＊

                       for RGSS3

        Ver 1.00   2014.09.24

   Authot：魂(Lctseng)，Bahamut forum ID：play123


   For redistribution, please keep this label

   Website：http://home.gamer.com.tw/homeindex.php?owner=play123

   Function：
   Most scripts related to images published by Lctseng-
   need to have this script as a base-script


   Update log：
    Ver 1.00 ：
    Date：2014.09.24
    Summary：■、First release


    This script modifies：
                           ■ Sprite

    This script adds the following categories and modules:
                           ■ SpriteDrawer
                           ■ SpriteFader
                           ■ SpriteSlider
                           ■ SpriteSensor
                           ■ SpriteZoomer


*******************************************************************************************
=end


#*******************************************************************************************
#
#   DO NOT MODIFY UNLESS YOU KNOW WHAT TO DO !
#
#*******************************************************************************************

#--------------------------------------------------------------------------
# ★ Script version information
#--------------------------------------------------------------------------
if !$lctseng_scripts
  $lctseng_scripts = {}
end


$lctseng_scripts[:sprite_ex] = "1.00"

puts "Load Script: Lctseng-Image Sprite Enhancement, Version：#{$lctseng_scripts[:sprite_ex]}"



#encoding:utf-8
#==============================================================================
# ■ Sprite
#------------------------------------------------------------------------------
# 　Area
#==============================================================================

class  Sprite
  #--------------------------------------------------------------------------
  # ● Perform sprite centering
  #--------------------------------------------------------------------------
  def center_sprite
    center_origin
    self.x = Graphics.width / 2
    self.y = Graphics.height / 2
  end
  #--------------------------------------------------------------------------
  # ● Centering the origin of the sprite
  #--------------------------------------------------------------------------
  def center_origin
    if self.bitmap
      self.ox = self.bitmap.width / 2
      self.oy = self.bitmap.height / 2
    end
  end
  #--------------------------------------------------------------------------
  # ● Is the mouse inside area?
  #--------------------------------------------------------------------------
  def mouse_in_area?
    if self.bitmap
      Mouse.area?(self.x - self.ox,self.y - self.oy,self.bitmap.width,self.bitmap.height)
    else
      false
    end
  end
  #--------------------------------------------------------------------------
  # ● Current position
  #--------------------------------------------------------------------------
  def current_pos
    [self.x , self.y]
  end
  #--------------------------------------------------------------------------
  # ● Set position
  #--------------------------------------------------------------------------
  def set_pos(pos)
    self.x = pos[0]
    self.y = pos[1]
  end
end


#encoding:utf-8
#==============================================================================
# ■ SpriteDrawer
#------------------------------------------------------------------------------
# 　Module that allows sprites to draw text like Window
# UPDATE：14008062248 Ver 1.3
#==============================================================================
module SpriteDrawer
  #--------------------------------------------------------------------------
  # ● Get window frame bitmap
  #--------------------------------------------------------------------------
  def windowskin
    Cache.system("Window")
  end
  #--------------------------------------------------------------------------
  # ● Get content size
  #--------------------------------------------------------------------------
  def text_size(str)
    self.bitmap.text_size(str)
  end
  #--------------------------------------------------------------------------
  # ● Get the drawn rectangle of the item
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new
    rect.width = item_width
    rect.height = item_height
    rect.x = index % col_max * (item_width + spacing)
    rect.y = index / col_max * item_height
    rect
  end
  #--------------------------------------------------------------------------
  # ● Get item width
  #--------------------------------------------------------------------------
  def item_width
    192
  end
  #--------------------------------------------------------------------------
  # ● Get item height
  #--------------------------------------------------------------------------
  def item_height
    line_height
  end
  #--------------------------------------------------------------------------
  # ● Get the number of columns
  #--------------------------------------------------------------------------
  def col_max
    return 1
  end
  #--------------------------------------------------------------------------
  # ● Get the width of the line spacing
  #--------------------------------------------------------------------------
  def spacing
    return 32
  end
  #--------------------------------------------------------------------------
  # ● Get text color
  #     n : Text color number（0..31）
  #--------------------------------------------------------------------------
  def text_color(n)
    windowskin.get_pixel(64 + (n % 8) * 8, 96 + (n / 8) * 8)
  end
  #--------------------------------------------------------------------------
  # ● Draw text
  #--------------------------------------------------------------------------
  def draw_text(*args,&block)
    self.bitmap.draw_text(*args,&block)
  end
  #--------------------------------------------------------------------------
  # ● Draw icon
  #     enabled : Valid sign. Draw with translucency when false
  #--------------------------------------------------------------------------
  def draw_icon(icon_index, x, y, enabled = true)
    temp_bitmap = Cache.system("Iconset")
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    self.bitmap.blt(x, y, temp_bitmap, rect, enabled ? 255 : translucent_alpha)
  end
  #--------------------------------------------------------------------------
  # ● Draw icon, specify target rectangle
  #     enabled : Valid sign. Draw with translucency when false
  #--------------------------------------------------------------------------
  def draw_icon_with_rect(icon_index,  target_rect ,enabled = true)
    temp_bitmap = Cache.system("Iconset")
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    self.bitmap.stretch_blt(target_rect, temp_bitmap, rect, enabled ? 255 : translucent_alpha)
  end
  #--------------------------------------------------------------------------
  # ● Get transparency for translucent drawing
  #--------------------------------------------------------------------------
  def translucent_alpha
    return 160
  end
  #--------------------------------------------------------------------------
  # ● Draw Item Name
  #     enabled : Valid sign. Draw with translucency when false
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, enabled = true, width = 172)
    return unless item
    draw_icon(item.icon_index, x, y, enabled)
    change_color(normal_color, enabled)
    draw_text(x + 24, y, width, line_height, item.name)
  end
  #--------------------------------------------------------------------------
  # ● Draw Item Detail Name
  #--------------------------------------------------------------------------
  def draw_detail_name(item, x, y, enabled = true, width = 172)
    return unless item.is_a?(Game_Equip_Details)
    color = item.fmts[1]
    match_item = item.get_match
    return unless match_item
    item_name = sprintf(item.fmts[0],match_item.name)
    item_icon_index = match_item.icon_index
    if enabled
      change_color(text_color(color),true)
    else
      change_color(normal_color, false)
    end
    draw_icon(item_icon_index, x, y, enabled)
    draw_text(x + 24, y, width, line_height, item_name)
  end
  #--------------------------------------------------------------------------
  # ● Draw name
  #--------------------------------------------------------------------------
  def draw_actor_name(actor, x, y, width = 112,align = 0)
    # change_color(hp_color(actor))
    draw_text(x, y, width, line_height, actor.name,align)
  end
  #--------------------------------------------------------------------------
  # ● Change content drawing color
  #     enabled : Valid sign. Draw with translucent when false
  #--------------------------------------------------------------------------
  def change_color(color, enabled = true)
    self.bitmap.font.color.set(color)
    self.bitmap.font.color.alpha = translucent_alpha unless enabled
  end
  #--------------------------------------------------------------------------
  # ● Change font
  #--------------------------------------------------------------------------
  def change_font(font)
    self.bitmap.font = font if self.bitmap
  end
  #--------------------------------------------------------------------------
  # ● Get line height
  #--------------------------------------------------------------------------
  def line_height
    return 24
  end
  #--------------------------------------------------------------------------
  # ● Change font size
  #--------------------------------------------------------------------------
  def change_font_size(sz)
    self.bitmap.font.size = sz
  end
  #--------------------------------------------------------------------------
  # ● Draw value bar content
  # Given: coordinates, maximum value, current value, file name
  #--------------------------------------------------------------------------
  def draw_gauge_content(dx,dy,current,max,filename)
    bitmap = Cache.battle(filename)
    rect = bitmap.rect.clone
    if max <= 0
      rate = 0
    else
      rate = (current.to_f/max)
    end
    rect.width = (rect.width * rate + 0.5).round
    self.bitmap.blt(dx,dy,bitmap,rect)
    change_color(normal_color)
    draw_text(dx,dy-3,bitmap.rect.width - 3,16,sprintf("%d / %d",current,max),2)
  end
  #--------------------------------------------------------------------------
  # ● Draw bullet information
  #--------------------------------------------------------------------------
  def draw_bullet_info_by_detail(detail,x,y,dw = 115 , dh = 18)
    # Font size setting: bullet type
    change_font(Lctseng.bullet_font)

    item = nil
    if detail
      item = detail.get_match
    end
    if item && item.need_bullet?
      ammo = detail.ammo
      bullet_item = ammo.item
      if detail.has_loaded_bullet_id? && bullet_item
        draw_bullet(ammo,x,y,dw,dh)
      else
        change_color(system_color)
        draw_text(x,y,dw,dh,"Not equipped with any bullets")
      end
    else
      # Bullet does not exist or is not needed
      change_color(system_color)
      draw_text(x,y,dw,dh,"No need to use bullets")
    end

  end
  #--------------------------------------------------------------------------
  # ● Draw bullet
  #--------------------------------------------------------------------------
  def draw_bullet(ammo,x,y,total_dw,dh)
    amount_dw = 40
    dw = total_dw - amount_dw
    item = ammo.item
    bullet = ammo.bullet_obj
    # Draw icon
    draw_icon_with_rect(item.icon_index,Rect.new(x,y,dh,dh))
    # coordinate displacement
    diff = (dh + 1)
    x += diff
    dw -= diff
    # Draw text

    change_color(text_color(6))
    name = bullet.display_name
    text_w = text_size(name).width
    #contents.fill_rect(Rect.new(x,y,dw,dh),Color.new(255,0,0))
    draw_text(x,y,dw,dh,name)

    # coordinate displacement
    x += ( text_w + 1 )
    # Drawing quantity
    amount = ammo.bullet_remain
    if amount > 0
      change_color(Color.new(0,255,0))
    else
      change_color(Color.new(255,0,0))
    end
    str = sprintf("(%d)",amount)
    #contents.fill_rect(Rect.new(x,y,amount_dw,dh),Color.new(255,255,0))
    draw_text(x,y,amount_dw,dh,str)

  end

  #--------------------------------------------------------------------------
  # ● Get various text colors
  #--------------------------------------------------------------------------
  def normal_color;      text_color(0);   end;    # default
  def system_color;      text_color(16);  end;    # system
  def crisis_color;      text_color(17);  end;    # danger
  def knockout_color;    text_color(18);  end;    # unable to fight
  def gauge_back_color;  text_color(19);  end;    # gauge bg color
  def hp_gauge_color1;   text_color(20);  end;    # HP gauge 1
  def hp_gauge_color2;   text_color(21);  end;    # HP gauge 2
  def mp_gauge_color1;   text_color(22);  end;    # MP gauge 1
  def mp_gauge_color2;   text_color(23);  end;    # MP gauge 2
  def mp_cost_color;     text_color(23);  end;    # use TP
  def power_up_color;    text_color(24);  end;    # capacity (changing equipment)
  def power_down_color;  text_color(25);  end;    # capacity (changing equipment)
  def tp_gauge_color1;   text_color(28);  end;    # TP gauge 1
  def tp_gauge_color2;   text_color(29);  end;    # TP gauge 2
  def tp_cost_color;     text_color(29);  end;    # use TP
  end



  #encoding:utf-8
#==============================================================================
# ■ SpriteFader
#------------------------------------------------------------------------------
# 　Allow sprites to fade in and out of the originals
#==============================================================================
module SpriteFader
  #--------------------------------------------------------------------------
  # ● Initial Fade Module
  #--------------------------------------------------------------------------
  def fader_init
    @fade_count = 0
    @fade_to = 0
    @fade_real_opacity = 0.0
    @fade_speed = 0.0
    @fade_post_handler = nil
    @fade_init = true
    @fade_processing = false
  end
  #--------------------------------------------------------------------------
  # ● Set fade in (set destination transparency and time)
  #--------------------------------------------------------------------------
  def fader_set_fade(to,time)
    @fade_count = time
    @fade_to = to.to_f
    @fade_real_opacity = self.opacity.to_f
    @fade_speed = ( @fade_to - @fade_real_opacity ) / @fade_count + 0.001
    @fade_processing = true
  end
  #--------------------------------------------------------------------------
  # ● Update fade
  #--------------------------------------------------------------------------
  def fader_update
    return if !@fade_init
    if @fade_count > 0
      @fade_count -= 1
      self.opacity = @fade_real_opacity += @fade_speed
    else
      if @fade_processing
        @fade_processing = false
        fader_post_fade
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Does it fade in or out?
  #--------------------------------------------------------------------------
  def fader_fading?
    @fade_init && @fade_count > 0
  end
  #--------------------------------------------------------------------------
  # ● Set post-fade processing
  #--------------------------------------------------------------------------
  def fader_set_post_handler(handler)
    @fade_post_handler = handler
  end
  #--------------------------------------------------------------------------
  # ● Call fade after call fade in
  #--------------------------------------------------------------------------
  def fader_post_fade
    if @fade_post_handler
      @fade_post_handler.call
    end
  end
  #--------------------------------------------------------------------------
  # ● Clear handler after call fade in
  #--------------------------------------------------------------------------
  def fader_clear_handler
    @fade_post_handler = nil
  end
end


#encoding:utf-8
#==============================================================================
# ■ SpriteSlider
#------------------------------------------------------------------------------
# 　Allow sprites to move components
#  UPDATE：1407091114
#==============================================================================
module SpriteSlider
  #--------------------------------------------------------------------------
  # ● Initialize the mobile module
  #--------------------------------------------------------------------------
  def slider_init
    @slide_count = 0
    @slide_real_pos = [0.0,0.0]
    @slide_from = [0,0]
    @slide_to = [0,0]
    @slide_speed = [0.0,0.0]
    @slide_init = true
    @slide_post_handler = nil
    @slide_processing = false
  end
  #--------------------------------------------------------------------------
  # ● Set up mobile
  #--------------------------------------------------------------------------
  def slider_set_move(from,to,time)
    @slide_count = time
    @slide_from = from.collect {|i| i.to_f}
    @slide_to = to.collect {|i| i.to_f}
    @slide_real_pos = @slide_from.clone
    # 設置速度
    2.times do |i|
      @slide_speed[i] = (@slide_to[i] - @slide_from[i]) / @slide_count
    end
    @slide_processing = true

  end
  #--------------------------------------------------------------------------
  # ● Update move
  #--------------------------------------------------------------------------
  def slider_update
    return if !@slide_init
    if @slide_count > 0
      @slide_count -= 1
      2.times do |i|
        @slide_real_pos[i] = @slide_real_pos[i] + @slide_speed[i]
      end
      self.x = @slide_real_pos[0]
      self.y = @slide_real_pos[1]
    else
      if @slide_processing
        slider_adjust_pos
        @slide_processing = false
        slider_post_method
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Fix last position
  #--------------------------------------------------------------------------
  def slider_adjust_pos
    self.x , self.y = @slide_to
  end
  #--------------------------------------------------------------------------
  # ● Does it move?
  #--------------------------------------------------------------------------
  def slider_sliding?
    @slide_init && @slide_count > 0
  end
  #--------------------------------------------------------------------------
  # ● Call after mobile method
  #--------------------------------------------------------------------------
  def slider_post_method
    if @slide_post_handler
      @slide_post_handler.call
    end
  end
  #--------------------------------------------------------------------------
  # ● Set up post-movement processing
  #--------------------------------------------------------------------------
  def slider_set_post_handler(handler)
    @slide_post_handler = handler
  end
  #--------------------------------------------------------------------------
  # ● Clear the handler after the call moves out
  #--------------------------------------------------------------------------
  def slider_clear_handler
    @slide_post_handler = nil
  end
  #--------------------------------------------------------------------------
  # ● Clear the handler after the call moves out
  #--------------------------------------------------------------------------
  def slider_clear_post_handler
    @slide_post_handler = nil
  end
end

#encoding:utf-8
#==============================================================================
# ■ SpriteSensor
# Update：1408061703 Ver 1.1
#------------------------------------------------------------------------------
# 　Let the sprite sense the originals needed for mouse placement
#==============================================================================
module SpriteSensor
  #--------------------------------------------------------------------------
  # ● Initialize the sensor module
  #--------------------------------------------------------------------------
  def sensor_init
    @sensor_init = true
    @sensor_hover_handler = nil
    @sensor_input_handler = nil
    @sensor_set_hover = false
    @sensor_set_input = false
    @active = false
  end
  #--------------------------------------------------------------------------
  # ● Other starting conditions
  #--------------------------------------------------------------------------
  def sensor_other_active_condition
    true
  end
  #--------------------------------------------------------------------------
  # ● Enable sensor
  #--------------------------------------------------------------------------
  def sensor_activate
    @active = true
  end
  #--------------------------------------------------------------------------
  # ● Disable sensor
  #--------------------------------------------------------------------------
  def sensor_deactivate
    @active = false
  end
  #--------------------------------------------------------------------------
  # ● Set up hovering handler
  #--------------------------------------------------------------------------
  def sensor_set_sense_hover(handler)
    @sensor_set_hover = true
    @sensor_hover_handler = handler
  end
  #--------------------------------------------------------------------------
  # ● Set up button induction handler
  #--------------------------------------------------------------------------
  def sensor_set_sense_input(handler)
    @sensor_set_input = true
    @sensor_input_handler = handler
  end
  #--------------------------------------------------------------------------
  # ● Is the mouse inside area?
  #--------------------------------------------------------------------------
  def sensor_mouse_in_area?
    if self.bitmap
      Mouse.area?(self.x - self.ox,self.y - self.oy,self.bitmap.width,self.bitmap.height)
    else
      false
    end
  end
  #--------------------------------------------------------------------------
  # ● How to check the call sensor
  #--------------------------------------------------------------------------
  def sensor_call_input
    if Input.trigger?(:C)
      @sensor_input_handler.call(:C)
    end
  end
  #--------------------------------------------------------------------------
  # ● Is the mouse inside the elf? Contains startup tests
  #--------------------------------------------------------------------------
  def sensor_mouse_in_area_safe?
    @sensor_init  && @active && sensor_mouse_in_area?
  end
  #--------------------------------------------------------------------------
  # ● Update induction
  #--------------------------------------------------------------------------
  def sensor_update
    return if !@sensor_init
    return if !@active
    return if !sensor_other_active_condition
    if @sensor_hover_handler
      if sensor_mouse_in_area?
        if @sensor_set_hover && @sensor_hover_handler
          @sensor_hover_handler.call(true)
        end
        if @sensor_set_input && @sensor_input_handler
          sensor_call_input
        end
      else
        if @sensor_set_hover && @sensor_hover_handler
          @sensor_hover_handler.call(false)
        end
      end
    end
  end
end

#encoding:utf-8
#==============================================================================
# ■ SpriteZoomer
#------------------------------------------------------------------------------
# 　The original required for the sprite to zoom in and out.
#  Instance variables begin with "_" and the public methods begin with "zoomer".
#==============================================================================
module SpriteZoomer
  #--------------------------------------------------------------------------
  # ● Initialize the zoom module
  #--------------------------------------------------------------------------
  def zoomer_init
    @_zoom_count = 0
    @_zoom_from = [0.0,0.0]
    @_zoom_to = [0.0,0.0]
    @_zoom_speed = [0.0,0.0]
    @_zoom_init = true
    @_zoom_post_handler = nil
    @_zoom_processing = false
  end
  #--------------------------------------------------------------------------
  # ● Set zoom
  #--------------------------------------------------------------------------
  def zoomer_set_effect(from,to,time)
    self.zoom_x , self.zoom_y = from
    @_zoom_count = time
    @_zoom_from = from
    @_zoom_to = to
    # 設置速度
    2.times do |i|
      @_zoom_speed[i] = (@_zoom_to[i] - @_zoom_from[i]) / @_zoom_count
    end
    @_zoom_processing = true

  end
  #--------------------------------------------------------------------------
  # ● Update zoom
  #--------------------------------------------------------------------------
  def zoomer_update
    return if !@_zoom_init
    if @_zoom_count > 0
      @_zoom_count -= 1
      self.zoom_x += @_zoom_speed[0]
      self.zoom_y += @_zoom_speed[1]
    else
      if @_zoom_processing
        @_zoom_processing = false
        zoomer_post_method
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Is it working?
  #--------------------------------------------------------------------------
  def zoomer_effect?
    @_zoom_init && @_zoom_count > 0
  end
  #--------------------------------------------------------------------------
  # ● Call the zoomed method
  #--------------------------------------------------------------------------
  def zoomer_post_method
    if @_zoom_post_handler
      @_zoom_post_handler.call
    end
  end
  #--------------------------------------------------------------------------
  # ● Set post-scaling processing
  #--------------------------------------------------------------------------
  def zoomer_set_post_handler(handler)
    @_zoom_post_handler = handler
  end
  #--------------------------------------------------------------------------
  # ● Clear call handler after zoom out
  #--------------------------------------------------------------------------
  def zoomer_clear_handler
    @_zoom_post_handler = nil
  end
end