[XP] Custom Blizz-ABS HUD

Started by winkio, November 23, 2008, 02:38:38 pm

Previous topic - Next topic

winkio

Template applied.

ATTENTION ALL BITS AND BYTES!  PREPARE FOR FORUM SECTION HYPERJUMP!  SECURE ALL LAUNCH DOORS!  PROCEED TO YOUR SEATS AND FASTEN YOUR SEATBELTS.  THANK YOU.

Landith

I have a suggestion..

You could make it where you can choose the option to have the actor's hp and sp centered or not, to make it look better if you have less than 4 actors.

Just a small suggestion lol

diablosbud

This is a good script, excellent for cooperative games. I have a quick error I would like to share, my order of scripts is:
Blizz-ABS Part1
Blizz-ABS Part2
Blizz-ABS Part3
Custom Blizz-ABS HUD (this script)
Chaos Project Debug Menu.

All the scripts are at their latest updates. But, upon new game startup (I didn't have anything to load, so I didn't test that) I got an error that states "Script 'Custom Blizz-ABS HUD' line 561: NoMethodError occurred. undefined method 'name' for #<Game_Map:0x8049020>". Could someone please help me solve this error.

winkio

December 11, 2008, 09:16:05 am #23 Last Edit: December 24, 2008, 03:32:26 pm by winkio
That error is caused because you don't have the map name addon.  I though I forgot to include something :^_^':!  That new version should work

UPDATED TO v1.10

What's new:
Optimized code - for those of you that wish to make your own edits, and to decrease lag
Max party size from 1 to 6 - works with any party size from 1 to 6.

Fantasist

I was gonna suggest that: use arrays, but you already did. And why is it limited to 6 party members? Technically, when you use arrays, you can go with as many as possible. I'm guessing it's the size of the HUD, right?
Do you like ambient/electronic music? Then you should promote a talented artist! Help out here. (I'm serious. Just listen to his work at least!)


The best of freeware reviews: Gizmo's Freeware Reviews




winkio

exactly.  6 is the max party members with a sizeable hp/sp bar width.  I'll soon add the option to always center the displays based on the party size, as it won't take more than a few minutes.  But it's christmas in 2 hours, and I just ate 40 raviolis and won big in a poker game, so I'm done for a little while.

Fantasist

Do you like ambient/electronic music? Then you should promote a talented artist! Help out here. (I'm serious. Just listen to his work at least!)


The best of freeware reviews: Gizmo's Freeware Reviews




RoseSkye

This script is good for more than one character parties but there is no hotkey display in the HUD.
Can anyone point me to a way I can display which skill is currently selected for this HUD?

Landith

I made it work but I had to take out the Gold display in the bottom left thing for it to work.
You want it..?

RoseSkye


Landith

March 31, 2009, 07:39:22 pm #30 Last Edit: March 31, 2009, 07:57:32 pm by Landith
Okay, give me a minute to add the EXP Bar back on.

Here ya go... Tell me if I messed anything up >.<
Spoiler: ShowHide

#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
# Blizz-ABS Party HUD by Winkio
# Version: 1.10
#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
#
#
#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
# This script modifies the Blizz-ABS HUD to display the HP/SP of up to four
# party members at once.  It also moves the hud and skill bar to the bottom and
# scales down the minimap.
#
# If you find any bugs, please report them here:
# http://forum.chaos-project.com
#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|

#==============================================================================
# Game_System
#------------------------------------------------------------------------------
#  This class was modified to support the party hud
#==============================================================================
class Game_System
  attr_accessor :parhud
end

#==============================================================================
# Scene_Title
#==============================================================================

class Scene_Title

  alias main_parhud_later main
  def main
    $map_infos = load_data('Data/MapInfos.rxdata')
    $map_infos.keys.each {|key| $map_infos[key] = $map_infos[key].name}
    main_parhud_later
  end
 
end

#==============================================================================
# Game_Map
#==============================================================================

class Game_Map
       
  def name
    return $map_infos[@map_id]
  end
   
end

#==============================================================================
# ParHud
#------------------------------------------------------------------------------
#  This class creates the top hud that shows the hp/sp of all party members and
#  their names.
#==============================================================================

class ParHud < Sprite
 
  #----------------------------------------------------------------------------
  # Initialization
  #  viewport - the viewport for the sprite
  #----------------------------------------------------------------------------
  def initialize(viewport = nil)
    # call superclass method
    super
    # create positions
    create_positions
    # create bitmap
    self.bitmap = Bitmap.new(640, 80)
    # set font
    self.bitmap.font.name = 'Arial'
    # set font size
    self.bitmap.font.size = 16
    # set font to bold
    self.bitmap.font.bold = true
    # set z coordinate
    self.z = 1000
    # set party size
    @psize = $game_party.actors.size
    @poffset = 0
    @hp, @maxhp = [0, 0, 0, 0], [0, 0, 0, 0]
    @sp, @maxsp = [0, 0, 0, 0], [0, 0, 0, 0]
    # draw basic HUD
    draw_basic
    # update
    update
  end
  #----------------------------------------------------------------------------
  # create_positions
  #  Sets drawing positions. This method can be aliased and the positions
  #  modified to create a different HUD.
  #----------------------------------------------------------------------------
  def create_positions
    @maxpsize = BlizzABS::Config::MAX_PARTY
    @name_x, @name_y, @hp_x, @hp_y, @sp_x, @sp_y = [], [], [], [], [], []
    (0...@maxpsize).each {|i|
      xdat = i*640/@maxpsize + 320/@maxpsize-50
      @name_x.push(xdat)
      @name_y.push(0)
      @hp_x.push(xdat)
      @hp_y.push(16)
      @sp_x.push(xdat)
      @sp_y.push(33)}
  end
  #----------------------------------------------------------------------------
  # draw_basic
  #  Draws the HUD template.
  #----------------------------------------------------------------------------
  def draw_basic
    self.bitmap.font.size = 16
    color = Color.new(255, 255, 255, 127)
    self.bitmap.font.color = Color.new(255, 255, 255)
    # if color exists
    if color.is_a?(Color)
      (0...@psize).each {|i|
        # draw outlines in color
        self.bitmap.fill_rect(@hp_x[i], @hp_y[i], 102, 14, color)
        self.bitmap.fill_rect(@sp_x[i], @sp_y[i], 102, 14, color)
        # draw actor's names
        self.bitmap.draw_text_full(@name_x[i], @name_y[i], 104, 20, actor(i).name, 1)
        }
    end
    self.bitmap.font.size = 14
  end
  #----------------------------------------------------------------------------
  # draw_empty
  #  Draws the HP and SP display when actor doesn't exist.
  #----------------------------------------------------------------------------
  def draw_empty
    # set font color
    self.bitmap.font.color = disabled_color
    (0...@psize).each {|i|
      # draw empty bars
      self.bitmap.gradient_bar_hud(@hp_x[i], @hp_y[i], 100, 0, 'hud_green_bar')
      self.bitmap.gradient_bar_hud(@sp_x[i], @sp_y[i], 100, 0, 'hud_blue_bar')
      # draw empty HP/SP
      self.bitmap.draw_text_full(@hp_x[i]+48, @hp_y[i]-3, 48, 20, '0', 2)
      self.bitmap.draw_text_full(@sp_x[i]+48, @sp_y[i]-3, 48, 20, '0', 2)
      }
    # reset all flag variables
    @hp = @sp = @maxhp = @maxsp = nil
  end
  #----------------------------------------------------------------------------
  # draw_hp
  #  Draws the HP display.
  #----------------------------------------------------------------------------
  def draw_hp
    @hp, @maxhp = [], []
    self.bitmap.font.color = normal_color
    (0...@psize).each {|i|
      # set current variables
      @hp.push(actor(i).hp)
      @maxhp.push(actor(i).maxhp)
      rate = (@maxhp[i] > 0 ? @hp[i].to_f / @maxhp[i] : 0)
      # draw gradient bar
      self.bitmap.gradient_bar_hud(@hp_x[i], @hp_y[i], 100, rate, 'hud_green_bar', 0)
      # draw HP
      self.bitmap.draw_text_full(@hp_x[i]+1, @hp_y[i], 100, 11, @hp[i].to_s, 1)
      }
  end
  #----------------------------------------------------------------------------
  # draw_sp
  #  Draws the SP display.
  #----------------------------------------------------------------------------
  def draw_sp
    @sp, @maxsp = [], []
    self.bitmap.font.color = normal_color
    (0...@psize).each {|i|
      # set current variables
      @sp.push(actor(i).sp)
      @maxsp.push(actor(i).maxsp)
      rate = (@maxsp[i] > 0 ? @sp[i].to_f / @maxsp[i] : 0)
      # draw gradient bar
      self.bitmap.gradient_bar_hud(@sp_x[i], @sp_y[i], 100, rate, 'hud_blue_bar', 0)
      # draw HP
      self.bitmap.draw_text_full(@sp_x[i]+1, @sp_y[i], 100, 11, @sp[i].to_s, 1)
      }
  end
  #----------------------------------------------------------------------------
  # update
  #  Checks if HUD needs refreshing.
  #----------------------------------------------------------------------------
  def update
    # if actor doesn't exist
    if actor == nil
      # unless already drawn empty HUD
      unless @empty_hud_drawn
        # draw HUD template
        draw_basic
        # draw empty HP, SP and EXP bars
        draw_empty
        # empty HUD was drawn
        @empty_hud_drawn = true
      end
    else
      if @psize != $game_party.actors.size
        @psize = $game_party.actors.size
        draw_basic
      end
      # if HUD needs refresh
      if $game_temp.hud_refresh
        # draw all data about actors
        draw_hp
        draw_sp
        # remove flag
        $game_temp.hud_refresh = nil
      else
        # draw data that needs to be updated
        test_offset
        test_hp
        test_sp
      end
      # empty HUD wasn't drawn
      @empty_hud_drawn = false
    end
  end
  #----------------------------------------------------------------------------
  # test_hp
  #  Tests and draws the HP.
  #----------------------------------------------------------------------------
  def test_hp
    (0...@psize).each {|i|
      # draw new HP if HP or max HP have changed
      if actor(i).hp != @hp[i] || actor(i).maxhp != @maxhp[i]
        draw_hp
        return
      end}
  end
  #----------------------------------------------------------------------------
  # test_sp
  #  Tests and draws the SP.
  #----------------------------------------------------------------------------
  def test_sp
    (0...@psize).each {|i|
      # draw new HP if HP or max HP have changed
      if actor(i).sp != @sp[i] || actor(i).maxsp != @maxsp[i]
        draw_sp
        return
      end}
  end
  #----------------------------------------------------------------------------
  # test_offset
  #  Tests and draws the SP.
  #----------------------------------------------------------------------------
  def test_offset
    (0...@psize).each {|i|
    if $game_party.actors[(i + @poffset)%@psize].name != $game_actors[1].name
      @poffset += 1
    else
      return
    end}
    @poffset %= @psize
  end
  #----------------------------------------------------------------------------
  # actor
  #  Returns the party leader's battler for easier reference.
  #----------------------------------------------------------------------------
  def actor(id = 0)
    return $game_party.actors[id + @poffset]
  end 
 
end

#==============================================================================
# Hud
#------------------------------------------------------------------------------
#  This class was modified to support SR display and modify the number of
#  skills left to use.
#  Displays HUD window and exp/level bar
#==============================================================================

class Hud < Sprite
 
  #----------------------------------------------------------------------------
  # Initialization
  #  viewport - the viewport for the sprite
  #----------------------------------------------------------------------------
  def initialize(viewport = nil)
    # call superclass method
    super
    # create positions
    create_positions
    # create bitmap
    self.bitmap = Bitmap.new(120, 90)
    # set font
    self.bitmap.font.name = 'Tahoma'
    # set font size
    self.bitmap.font.size = 16
    # set font to bold
    self.bitmap.font.bold = true
    # set x and y coordinates
    self.x, self.y = @hud_x, @hud_y
    # set z coordinate
    self.z = 1000
    # draw basic HUD
    draw_basic
    # update
    update
  end
  #----------------------------------------------------------------------------
  # create_positions
  #  Sets drawing positions. This method can be aliased and the positions
  #  modified to create a different HUD.
  #----------------------------------------------------------------------------
  def create_positions
    @hud_height, @hud_width, @hud_x, @hud_y = 130, 120, 0, 390
    @level_x, @level_y = 0, 0
    @er_x, @er_y, @loc_x, @loc_y = 10, 40, 10, 10
    @sbar_x, @sbar_y = 65, 60
    @hot_x, @hot_y, @left_x, @left_y = 14, 50, 14, 74
  end
  #----------------------------------------------------------------------------
  # draw_basic
  #  Draws the HUD template.
  #----------------------------------------------------------------------------
  def draw_basic
    # fill with grey rectangle
    self.bitmap.fill_rect(0, 0, @hud_width, @hud_height,
        Color.new(0, 0, 0, 127))
    color = Color.new(255, 255, 255, 127)
    # if color exists
    if color.is_a?(Color)
      # draw outlines in color
      self.bitmap.fill_rect(@level_x, @level_y-15, 120, 14, color)
    end
    # set font color
    self.bitmap.font.color = system_color
  end
  #----------------------------------------------------------------------------
  # draw_empty
  #  Draws the HP and SP display when actor doesn't exist.
  #----------------------------------------------------------------------------
  def draw_empty
    self.bitmap.gradient_bar_hud(@level_x+1, @level_y-14, 118, 'hud_white_bar', 1)
    # set font color
    self.bitmap.font.color = disabled_color
    # draw empty HP
    self.bitmap.draw_text_full(@level_x, @level_y-14, 118, 11, '0', 1)
    # reset all flag variables
    @name = @level = @hp = @sp = @maxhp = @maxsp = @exp = @states = @skill =
        @skills_left = @item = @items_left = @gold = nil
  end
  #----------------------------------------------------------------------------
  # draw_exp
  #  Draws the EXP display.
  #----------------------------------------------------------------------------
  def draw_exp
    # set current variables
    @exp, @level = actor.exp, actor.level
    # set fill rate
    rate = (actor.next_exp != 0 ? actor.now_exp.to_f / actor.next_exp  : 1)
    # draw gradient bar
    self.bitmap.gradient_bar_hud(@level_x, @level_y, 118, rate, 'hud_white_bar', 2)
    # set font color depending on how many HP left
    self.bitmap.font.color = normal_color
    self.bitmap.font.size = 14
    # draw EXP
    self.bitmap.draw_text_full(@level_x, @level_y-3, 118, 20, 'Level ' + @level.to_s, 1)
  end
  #----------------------------------------------------------------------------
  # draw_er
  #  Draws the er display.
  #----------------------------------------------------------------------------
  def draw_er
    self.bitmap.fill_rect(@loc_x-10, @loc_y+20, 100, 20, Color.new(0, 0, 0, 127))
    self.bitmap.font.color, self.bitmap.font.size = normal_color, 12
    self.bitmap.draw_text_full(@loc_x-30, @loc_y+20, 100, 20, "Skills", 1)
    self.bitmap.draw_text_full(@loc_x+30, @loc_y+20, 100, 20, "Items", 1)
  end
  #----------------------------------------------------------------------------
  # draw_loc
  #  Draws the map location display.
  #----------------------------------------------------------------------------
  def draw_loc
    # set current variable
    @loc = $game_map.name
    # remove old display
    self.bitmap.fill_rect(@loc_x, @loc_y+4, 100, 20, Color.new(0, 0, 0, 127))
    # set font color
    self.bitmap.font.color, self.bitmap.font.size = normal_color, 16
    # draw party's gold   
    self.bitmap.draw_text_full(@loc_x, @loc_y, 100, 20, $game_map.name, 1)
    self.bitmap.font.size = 12
  end
  #----------------------------------------------------------------------------
  # draw_hskill
  #  Draws the hot skill display.
  #----------------------------------------------------------------------------
  def draw_hskill
    # set current variable
    @skill = actor.skill
    # remove old display
    self.bitmap.fill_rect(@hot_x+5, @hot_y, 24, 24, Color.new(0, 0, 0, 128))
    # if skill hot skill exists
    if @skill != 0
      # load bitmap
      bitmap = RPG::Cache.icon($data_skills[@skill].icon_name)
      # draw bitmap
      self.bitmap.blt(@hot_x+5, @hot_y, bitmap, Rect.new(0, 0, 24, 24))
    end
    # removes skills left to use display
    draw_lskill
  end
  #----------------------------------------------------------------------------
  # draw_lskill
  #  Draws the skills left to use display.
  #----------------------------------------------------------------------------
  def draw_lskill
    # remove old display
    self.bitmap.fill_rect(@left_x+5, @left_y, 24, 16, Color.new(0, 0, 0, 128))
    # get the number of skills left
    @skills_left = get_skills_left
    # if hot skill exists
    if @skill != nil && @skill > 0
      # if normal SP cost
      if @skills_left >= 0
        # if not enough sp to use
        if @skills_left == 0
          # set font color
          self.bitmap.font.color = Color.new(255, 0, 0)
        # if enough SP for 5 or less skill uses
        elsif @skills_left <= 5
          # set font color
          self.bitmap.font.color = Color.new(255, 255, 0)
        else
          # set font color
          self.bitmap.font.color = normal_color
        end
        # decrease font color
        self.bitmap.font.size -= 2
        # draw number how many skills left to use
        self.bitmap.draw_text_full(@left_x+5, @left_y, 24, 20, @skills_left.to_s, 1)
        # increase font size
        self.bitmap.font.size += 2
      # if infinite skills left
      elsif @skills_left == -1
        # set font color
        self.bitmap.font.color = Color.new(0, 255, 0)
        # increase font size
        self.bitmap.font.size += 4
        # draw "∞" skill uses left
        self.bitmap.draw_text_full(@left_x+5, @left_y, 24, 20, '∞', 1)
        # decrease font size
        self.bitmap.font.size -= 4
      end
    end
  end
  #----------------------------------------------------------------------------
  # get_skills_left
  #  Gets the number of skill usages left.
  #----------------------------------------------------------------------------
  def get_skills_left
    # if skill hot skill exists
    if @skill != nil && @skill > 0
      # if SP cost is zero
      if $data_skills[@skill].sp_cost > 0
        # get basic SP cost
        sp_cost = $data_skills[@skill].sp_cost
        # if using SP Cost Mod Status
        if $tons_version != nil && $tons_version >= 6.54 &&
            $game_system.SP_COST_MOD
          # get modified cost
          sp_cost = BlizzCFG.get_cost_mod(actor.states, sp_cost)
        end
        # infinite
        return -1 if sp_cost == 0
        # calculate skills left to use
        return @sp / sp_cost
      end
      # set flag
      return -1
    end
    # set flag
    return -2
  end
  #----------------------------------------------------------------------------
  # draw_hitem
  #  Draws the hot item display.
  #----------------------------------------------------------------------------
  def draw_hitem
    # set current variable
    @item = actor.item
    # remove old display
    self.bitmap.fill_rect(@hot_x+60, @hot_y, 24, 24, Color.new(0, 0, 0, 128))
    # if hot item exists
    if @item != 0
      # load bitmap
      bitmap = RPG::Cache.icon($data_items[@item].icon_name)
      # draw bitmap
      self.bitmap.blt(@hot_x+60, @hot_y, bitmap, Rect.new(0, 0, 24, 24))
    end
    # removes items left to use display
    draw_litem
  end
  #----------------------------------------------------------------------------
  # draw_litem
  #  Draws the items left to use display.
  #----------------------------------------------------------------------------
  def draw_litem
    # set current variable
    @items_left = $game_party.item_number(@item)
    # remove old display
    self.bitmap.fill_rect(@left_x+60, @left_y, 24, 16, Color.new(0, 0, 0, 128))
    # if hot item exists
    if @item != nil && @item > 0
      # if item exists and cannot be consumed
      if $data_items[@item] != nil && !$data_items[@item].consumable
        # set font color
        self.bitmap.font.color = Color.new(0, 255, 0)
        # increase font size
        self.bitmap.font.size += 4
        # draw "∞" items left
        self.bitmap.draw_text_full(@left_x+60, @left_y, 24, 20, '∞', 1)
        # decrease font size
        self.bitmap.font.size -= 4
      else
        # if no items left
        if @items_left == 0
          # set font color
          self.bitmap.font.color = Color.new(255, 0, 0)
        # if equal or less items left
        elsif @items_left <= 10
          # set font color
          self.bitmap.font.color = Color.new(255, 255, 0)
        else
          # set font color
          self.bitmap.font.color = normal_color
        end
        # decrease font color
        self.bitmap.font.size -= 2
        # draw number how many items left to use
        self.bitmap.draw_text_full(@left_x+60, @left_y, 24, 20, @items_left.to_s, 1)
        # increase font size
        self.bitmap.font.size += 2
      end
    end
  end
  #----------------------------------------------------------------------------
  # update
  #  Checks if HUD needs refreshing.
  #----------------------------------------------------------------------------
  def update
    # if actor doesn't exist
    if actor == nil
      # unless already drawn empty HUD
      unless @empty_hud_drawn
        # draw HUD template
        draw_basic
        # draw empty HP, SP and EXP bars
        draw_empty
        # empty HUD was drawn
        @empty_hud_drawn = true
      end
    else
      # if HUD needs refresh
      if $game_temp.hud_refresh
        # draw all data about actors
        draw_exp
        draw_er
        draw_loc
        unless BlizzABS::Config::DIRECT_HOTKEYS
          draw_hskill
          draw_lskill
          draw_hitem
          draw_litem
        end
        # remove flag
        $game_temp.hud_refresh = nil
      else
        # draw data that needs to be updated
        test_exp
        test_er
        test_loc
        unless BlizzABS::Config::DIRECT_HOTKEYS
          test_hskill
          test_lskill
          test_hitem
          test_litem
        end
      end
      # empty HUD wasn't drawn
      @empty_hud_drawn = false
    end
  end
  #----------------------------------------------------------------------------
  # test_exp
  #  Tests and draws the EXP.
  #----------------------------------------------------------------------------
  def test_exp
    # draw new HP if HP or max HP have changed
    draw_exp if actor.exp != @exp
  end
  #----------------------------------------------------------------------------
  # test_er
  #  Tests and draws the er.
  #----------------------------------------------------------------------------
  def test_er
    # draw new er if er has changed
    draw_er if $game_party.gold != @er
  end
  #----------------------------------------------------------------------------
  # test_loc
  #  Tests and draws the loc.
  #----------------------------------------------------------------------------
  def test_loc
    # draw new er if er has changed
    draw_loc if $game_map.name != @loc
  end
  #----------------------------------------------------------------------------
  # actor
  #  Returns the party leader's battler for easier reference.
  #----------------------------------------------------------------------------
  def actor
    return $game_player.battler
  end
  #----------------------------------------------------------------------------
  # dispose
  #  Removes PARHUD from screen and memory.
  #----------------------------------------------------------------------------
  def dispose
    @parhud = nil
    # call superclass method
    super
  end
 
end

#==============================================================================
# Hotkey_Assignment
#------------------------------------------------------------------------------
#  This class creates and display currently assigned hotkeys and is more
#  effiecient than the Window class.
#  Changed to display at bottom of screen with new graphics.
#==============================================================================

class Hotkey_Assignment < Sprite
 
  #----------------------------------------------------------------------------
  # Initialization
  #  viewport - the viewport for the sprite
  #----------------------------------------------------------------------------
  def initialize(viewport = nil)
    # call superclass
    super
    # create bitmap
    self.bitmap = Bitmap.new(320, 32)
    # set font to bold
    self.bitmap.font.bold = true
    # decrease font size
    self.bitmap.font.size -= 8
    # set font color
    self.bitmap.font.color = system_color
    # set x and y position
    self.x, self.y, self.z = 160, 448, 1100
    @page = 1
    # skill IDs on hotkeys
    @skills = BlizzABS::Cache::EmptyKeys
    # item IDs on hotkeys
    @items = BlizzABS::Cache::EmptyKeys
    # update display
    update
  end
  #----------------------------------------------------------------------------
  # draw
  #  Draws the hotkey display.
  #----------------------------------------------------------------------------
  def draw(index = nil)
    # iterate through all hotkeys
    (index == nil ? BlizzABS::Cache::HotkeyRange : [index]).each {|i|
        # if hotkey is skill hotkey
        if $game_player.skill_hotkeys[i%10] != 0
          # temporary object
          object = $data_skills[$game_player.skill_hotkeys[i%10]]
        # if hotkey is item hotkey
        elsif $game_player.item_hotkeys[i%10] != 0
          # temporary object
          object = $data_items[$game_player.item_hotkeys[i%10]]
        end
        # if any change applied (10 is used for 0)
        if @items[i%10] != $game_player.item_hotkeys[i%10] ||
            @skills[i%10] != $game_player.skill_hotkeys[i%10]
          # remove this icon
          self.bitmap.fill_rect(32*(i-1), 0, 32, 32, Color.new(0, 0, 0, 0))
          # fill icon bachground
          self.bitmap.fill_rect(32*(i-1)+4, 4, 24, 24, Color.new(0, 0, 0, 128))
          # if object exists
          if object != nil
            # load bitmap
            bitmap = RPG::Cache.icon(object.icon_name)
            # draw bitmap
            self.bitmap.blt(32*(i-1)+4, 4, bitmap, Rect.new(0, 0, 24, 24))
          end
          # draw hotkey number
          self.bitmap.draw_text_full(32*(i-1), 10, 30, 32, (i%10).to_s, 2)
        end}
    # set new items
    @items = $game_player.item_hotkeys.clone
    # set new skills
    @skills = $game_player.skill_hotkeys.clone
  end
end

#==============================================================================
# Minimap
#------------------------------------------------------------------------------
#  This class creates and handels the minimap/fullscreen map display and is
#  more efficient than the Window class.
#  Changed to 6x6 tiles with rounded edges
#==============================================================================

class Minimap < Sprite
 
  # setting all accessible variables
  attr_reader :map_id
  #----------------------------------------------------------------------------
  # Initialization
  #----------------------------------------------------------------------------
  def initialize
    # call superclass method
    super(Viewport.new(520, 390, 120, 90))
    # get autotile image from Blizz-ABS Cache
    @autotile = minimap_autotile
    # creates the passable floor map
    create_passable_floor
    # set x and y position
    self.x, self.y = 0, 0
    # set z position
    viewport.z = 5000
    # store events
    @events, @names = check_events
    # create sprites for events
    create_sevents
    # set all sprites visible
    self.visible = true
  end
  #--------------------------------------------------------------------------
    # minimap_autotile
    #  Creates the minimap autotile for passability.
    #--------------------------------------------------------------------------
    def minimap_autotile
      b = Bitmap.new(18, 24)
      c1 = Color.new(191, 191, 191)
      c2 = Color.new(255, 255, 255)
      b.fill_rect(0, 0, 6, 6, c1)
      b.fill_rect(12, 0, 6, 6, c1)
      #bottom 3x3 square
      b.fill_rect(2, 8, 14, 14, c1)
      b.fill_rect(1, 10, 1, 10, c1)
      b.fill_rect(4, 7, 10, 1, c1)
      b.fill_rect(16, 10, 1, 10, c1)
      b.fill_rect(4, 22, 10, 1, c1)
      #highlight pixels
      b.fill_rect(4, 6, 10, 1, c2)
      b.fill_rect(14, 7, 2, 1, c2)
      b.fill_rect(16, 8, 1, 2, c2)
      b.fill_rect(17, 10, 1, 10, c2)
      b.fill_rect(16, 20, 1, 2, c2)
      b.fill_rect(14, 22, 2, 1, c2)
      b.fill_rect(4, 23, 10, 1, c2)
      b.fill_rect(2, 22, 2, 1, c2)
      b.fill_rect(1, 20, 1, 2, c2)
      b.fill_rect(0, 10, 1, 10, c2)
      b.fill_rect(1, 8, 1, 2, c2)
      b.fill_rect(2, 7, 2, 1, c2)
      return b
    end
  #----------------------------------------------------------------------------
  # create_passable_floor
  #  Creates the passable floor map on the bitmap.
  #----------------------------------------------------------------------------
  def create_passable_floor
    # delete bitmap if bitmap exists
    self.bitmap.dispose if self.bitmap != nil
    # store new map ID
    @map_id = $game_map.map_id
    # temporary width and height
    w, h = $game_map.width, $game_map.height
    # create bitmap
    self.bitmap = Bitmap.new(6*w, 6*h)
    # fill rectangle
    self.bitmap.fill_rect(0, 0, 6*w, 6*h, Color.new(0, 0, 0, 128))
    # get passability data
    v_map = $game_map.virtual_passability
    # iterate through all tiles
    (0...v_map.xsize).each {|x| (0...v_map.ysize).each {|y|
        # depending on passable direction, draw the path using the autotile
        case v_map[x, y]
        when 0x01 #    D
          self.bitmap.blt(x*6, y*6+3, @autotile, Rect.new(0, 0, 6, 3), 128)
        when 0x02 #   L
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(3, 0, 3, 6), 128)
        when 0x03 #   LD
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(12, 6, 6, 6), 128)
        when 0x04 #  R
          self.bitmap.blt(x*6+3, y*6, @autotile, Rect.new(0, 0, 3, 6), 128)
        when 0x05 #  R D
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(0, 6, 6, 6), 128)
        when 0x06 #  RL
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(6, 6, 6, 3), 128)
          self.bitmap.blt(x*6, y*6+3, @autotile, Rect.new(6, 21, 6, 3), 128)
        when 0x07 #  RLD
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(6, 6, 6, 6), 128)
        when 0x08 # U
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(0, 3, 6, 3), 128)
        when 0x09 # U  D
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(0, 12, 3, 6), 128)
          self.bitmap.blt(x*6+3, y*6, @autotile, Rect.new(15, 12, 3, 6), 128)
        when 0x0A # U L
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(12, 18, 6, 6), 128)
        when 0x0B # U LD
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(12, 12, 6, 6), 128)
        when 0x0C # UR
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(0, 18, 6, 6), 128)
        when 0x0D # UR D
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(0, 12, 6, 6), 128)
        when 0x0E # URL
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(6, 18, 6, 6), 128)
        when 0x0F # URLD
          self.bitmap.blt(x*6, y*6, @autotile, Rect.new(6, 12, 6, 6), 128)
        end}}
  end
  #----------------------------------------------------------------------------
  # update
  #  Updates the minimap and sprite movement on the minimap.
  #----------------------------------------------------------------------------
  def update(override = false)
    # creates the passable floor map if new map entered
    create_passable_floor if @map_id != $game_map.map_id
    # get events
    ev = check_events
    # if events or names changed
    if [@events, @names] != ev
      # store new events and names
      @events, @names = ev
      # delete sprites of events
      destroy_sevents
      # create sprites of events
      create_sevents
    end
    # if minimap not in fullscreen mode
    if $game_system.minimap < 2
      # set offset display
      self.ox, self.oy = $game_map.display_x * 6 / 128, $game_map.display_y * 6 / 128
    # if not pressed the turn button to scroll map around
    elsif !($game_system.turn_button && Input.press?(Input::Turn)) || override
      # if map can be scrolled horizontally
      if self.bitmap.width > 640
        # coordinate
        border = $game_player.real_x * 6 / 128 - 320
        # get right border
        border_x = self.bitmap.width - 640
        # set offset
        if border < 0
          self.ox = 0
        elsif border > border_x
          self.ox = border_x
        else
          self.ox = border
        end
      else
        # center map display horizontally
        self.ox = self.bitmap.width/2 - 320
      end
      # if map can be scrolled vertically
      if self.bitmap.height > 480
        # coordinate
        border = $game_player.real_y * 6 / 128 - 240
        # get lower border
        border_y = self.bitmap.height - 480
        # set offset
        if border < 0
          self.oy = 0
        elsif border > border_y
          self.oy = border_y
        else
          self.oy = border
        end
      else
        # center map display vertically
        self.oy = self.bitmap.height/2 - 240
      end
    end
    # iterate through all sprites
    @sevents.each_index {|i|
        # if minimap is not in fullscreen mode and within the range of ABSEAL
        if $game_system.minimap == 2 || @events[i].update?
          # set new coordinates
          @sevents[i].x = self.x + @events[i].real_x * 6 / 128
          @sevents[i].y = self.y + @events[i].real_y * 6 / 128
          # set offsets
          @sevents[i].ox, @sevents[i].oy = self.ox, self.oy
          # if event has a spriteset
          if @names[i] != '' && !@events[i].dropped &&
              (@events[i].is_a?(Map_Actor) ||
              !@events[i].name.clone.gsub!('\box') {''})
            # depending on the facing direction of the event
            @sevents[i].src_rect.set((@events[i].direction-2)*7, 0, 14, 14)
            # change offsets
            @sevents[i].ox += 3
            @sevents[i].oy += 3
          end
        end}
  end
  #----------------------------------------------------------------------------
  # create_sevents
  #  Creates for each event on the map a sprite on the minimap.
  #----------------------------------------------------------------------------
  def create_sevents
    # set empty array
    @sevents = []
    # ierate through all events on the minimap
    @events.each_index {|i|
        # create sprite
        sprite = Sprite.new(viewport)
        # temporary variable
        rect = Rect.new(0, 0, 56, 14)
        # if event is player
        if @events[i] == $game_player
          # if player has spriteset
          if @names[i] != ''
            # create bitmap
            sprite.bitmap = Bitmap.new(56, 14)
            # get green arrow
            sprite.bitmap.blt(0, 0, $BlizzABS.cache.image('green_arrow'), rect, 128)
          end
          # highest sprite
          sprite.z = 100
        # if event is actor
        elsif @events[i].is_a?(Map_Actor)
          # if actor has spriteset
          if @names[i] != ''
            # create bitmap
            sprite.bitmap = Bitmap.new(56, 14)
            # get blue arrow
            sprite.bitmap.blt(0, 0, $BlizzABS.cache.image('blue_arrow'), rect, 128)
          end
          # 2nd highest sprite
          sprite.z = 80
        # if event is enemy
        elsif @events[i].class == Map_Enemy
          # if event without spriteset or "boxdraw" enforcing
          if @names[i] == '' || @events[i].name.clone.gsub!('\box') {''}
            # create bitmap
            sprite.bitmap = Bitmap.new(6, 6)
            # fill rectangle with black color
            sprite.bitmap.fill_rect(0, 0, 6, 6, Color.new(0, 0, 0, 128))
            # fill rectangle with red color
            sprite.bitmap.fill_rect(1, 1, 4, 4, Color.new(255, 0, 0, 128))
          else
            # create bitmap
            sprite.bitmap = Bitmap.new(56, 14)
            # get red arrow
            sprite.bitmap.blt(0, 0, $BlizzABS.cache.image('red_arrow'), rect, 128)
          end
          # 5th highest sprite
          sprite.z = 50
        # if event is dropped item
        elsif @events[i].dropped
          # create bitmap
          sprite.bitmap = Bitmap.new(8, 8)
          # fill rectangle with black color
          sprite.bitmap.fill_rect(0, 0, 8, 8, Color.new(0, 0, 0, 128))
          # fill rectangle with cyan color
          sprite.bitmap.fill_rect(1, 1, 6, 6, Color.new(0, 255, 255, 128))
          # 3rd highest sprite
          sprite.z = 70
        # if event is normal event
        elsif @events[i].class == Game_Event
          # if event has spc command
          if @events[i].name.clone.gsub!('\spc') {''}
            # temporary variables, 4th highest sprite
            color, arrow, sprite.z = Color.new(255, 255, 0, 128), 'yellow_arrow', 60
          # if event code exists and te
          elsif @events[i].teleport
            # temporary variables, 6th highest sprite
            color, arrow, sprite.z = Color.new(128, 0, 255, 128), 'violet_arrow', 40
          end
          # if event without spriteset or "boxdraw" enforcing
          if @names[i] == '' || @events[i].name.clone.gsub!('\box') {''}
            # create bitmap
            sprite.bitmap = Bitmap.new(6, 6)
            # fill rectangle with black color
            sprite.bitmap.fill_rect(0, 0, 6, 6, Color.new(0, 0, 0, 128))
            # fill rectangle with yellow color
            sprite.bitmap.fill_rect(1, 1, 4, 4, color)
          else
            # create bitmap
            sprite.bitmap = Bitmap.new(56, 14)
            # get yellow or violet arrow
            sprite.bitmap.blt(0, 0, $BlizzABS.cache.image(arrow), rect, 128)
          end
        # if event without spriteset or "boxdraw" enforcing
        elsif @names[i] == '' || @events[i].name.clone.gsub!('\box') {''}
          # create bitmap
          sprite.bitmap = Bitmap.new(6, 6)
          # fill rectangle with black color
          sprite.bitmap.fill_rect(0, 0, 6, 6, Color.new(0, 0, 0, 128))
          # fill rectangle with default white color
          sprite.bitmap.fill_rect(1, 1, 4, 4, Color.new(255, 255, 255, 128))
        else
          # create bitmap
          sprite.bitmap = Bitmap.new(56, 14)
          # get white arrow
          sprite.bitmap.blt(0, 0, $BlizzABS.cache.image('white_arrow'), Rect.new(0, 0, 56, 14), 128)
        end
        # create a little dummy bitmap in case no bitmap was created before
        sprite.bitmap = Bitmap.new(1, 1) if sprite.bitmap == nil
        # get sprite out of map screen so ABSEAL can work correctly
        sprite.ox = sprite.oy = 64
        # if event has a spriteset
        if sprite.bitmap.width != 6
          # depending on the facing direction of the event
          sprite.src_rect.set((@events[i].direction-2)*7, 0, 14, 14)
        end
        # add sprite to array
        @sevents.push(sprite)}
      end
     
end


#==============================================================================
# Scene_Map
#------------------------------------------------------------------------------
#  This class was enhanced to support HUD control and creation system and
#  Blizz-ABS battle handling and level up text display.
#  Changed to enable the party hud
#==============================================================================

class Scene_Map
 
  #----------------------------------------------------------------------------
  # override main
  #----------------------------------------------------------------------------
  alias main_blizzabs_later_winkio main
  def main
    # create HUD if HUD is turned on and HUD active
    @hud = Hud.new if $game_system.hud
    @parhud = ParHud.new if $game_system.parhud
    # if HOTKEYS is turned on and assignment display active
    if $game_system.hotkeys
      # create assignment display
      @hotkeys = Hotkey_Assignment.new
    end
    # if MINIMAP is turned on and minimap active
    if $game_system.minimap > 0
      # create HUD
      @minimap = Minimap.new
    end
    # tests and sets the in_battle flag
    test_in_battle
    # call original method
    main_blizzabs_later
    # set in_battle flag
    $game_temp.in_battle = false
    # delete HUD elements that exist
    [@hud, @parhud, @hotkeys, @minimap].each {|s| s.dispose if s != nil}
  end
  #----------------------------------------------------------------------------
  # hud_update
  #  This method contains a couple of routine calls to handle with the HUD.
  #----------------------------------------------------------------------------
  def hud_update
    # check activation of HUD parts
    check_huds
    # update minimap
    update_minimap
    # update hotkey assignment display
    update_hotkeys
    # iterate through all the HUD sprites
    [@hud, @parhud, @minimap, @hotkeys].each {|s|
        # if sprite exists
        if s != nil
          # update sprite
          s.update
          # if player is on the same position as one of the sprites on the screen
          if $game_player.screen_x < s.vx + s.vw + 16 &&
              $game_player.screen_y < s.vy + s.vh + 48 &&
              $game_player.screen_x > s.vx && $game_player.screen_y > s.vy &&
              ((s == @minimap) ? ($game_system.minimap < 2) : true)
            # decrease opacity quickly if critical opacity not reached
            s.opacity -= 25 if s.opacity > 80
          # if not full opacity
          elsif s.opacity <= 255
            # increase opacity quickly if critical opacity not reached
            s.opacity += 25
          end
        end}
  end
  #----------------------------------------------------------------------------
  # check_huds
  #  This method handles enabling and disabling the HUD parts on the map.
  #----------------------------------------------------------------------------
  def check_huds
    # if minimap button is enabled and pressed
    if $game_system.minimap_button && Input.trigger?(Input::Minimap)
      # trigger minimap active
      $game_system.minimap = ($game_system.minimap + 1) % 2  #change123
    end
    # if hotkey display button is enabled and pressed
    if $game_system.hotkey_button && Input.trigger?(Input::Hotkey)
      # trigger hotkey display active
      $game_system.hotkeys = (!$game_system.hotkeys)
    end
    # if HUD button is enabled and pressed
    if $game_system.hud_button && Input.trigger?(Input::Hud)
      # trigger it active
      $game_system.hud = (!$game_system.hud)
      $game_system.parhud = (!$game_system.parhud)
    end
    # if minimap not active and minimap exists
    if $game_system.minimap == 0 && @minimap != nil
      # delete it
      @minimap.dispose
      @minimap = nil
    # if minimap is turned on and active and doesn't exist
    elsif BlizzABS::Config::MINIMAP && $game_system.minimap > 0
      # create it
      @minimap = Minimap.new if @minimap == nil
    end
    # if assignment display not active and exists
    if !$game_system.hotkeys && @hotkeys != nil
      # delete it
      @hotkeys.dispose
      @hotkeys = nil
    # if HOTKEYS is turned on and active and doesn't exist
    elsif BlizzABS::Config::HOTKEYS && $game_system.hotkeys
      # create it
      @hotkeys = Hotkey_Assignment.new if @hotkeys == nil
    end
    # if HUD not active and HUD exists
    if !$game_system.hud && @hud != nil
      # delete it
      @hud.dispose
      @hud = nil
      @parhud.dispose
      @parhud = nil
    # if HUD is turned on and HUD active and HUD doesn't exist
    elsif BlizzABS::Config::HUD_ENABLED && $game_system.hud
      # create it
      @hud = Hud.new if @hud == nil
      @parhud = ParHud.new if @parhud == nil
    end
  end
 
end
#==============================================================================
# Window_Skill_Hotkey
#------------------------------------------------------------------------------
#  This class serves as display for skills that can be hotkeyed.
#  Changed position to top of screen
#==============================================================================

class Window_Skill_Hotkey < Window_Skill
 
  #----------------------------------------------------------------------------
  # Initialization
  #  actor - actor
  #----------------------------------------------------------------------------
  def initialize(actor)
    # call superclass method
    super
    # set max column number
    @column_max = 1
    # set width and height
    self.width, self.height = 320, 416
    # set y and z position
    self.y, self.z = 0, 21000
    # remove cursor display
    self.cursor_rect.empty
    # set to not active
    self.active = false
    # refresh display
    refresh
  end
 
end

#==============================================================================
# Window_Item_Hotkey
#------------------------------------------------------------------------------
#  This class serves as display for items that can be hotkeyed.
#  Changed position to top of screen
#==============================================================================

class Window_Item_Hotkey < Window_Item
 
  #----------------------------------------------------------------------------
  # Initialization
  #  actor - actor
  #----------------------------------------------------------------------------
  def initialize
    # call superclass method
    super
    # set max column number
    @column_max = 1
    # set width and height
    self.width, self.height = 320, 416
    # set x, y and z position
    self.x, self.y, self.z = 320, 0, 21000
    # remove cursor display
    self.cursor_rect.empty
    # set to not active
    self.active = false
    # refresh display
    refresh
  end
 
end

#==============================================================================
# Scene_Hotkeys
#------------------------------------------------------------------------------
#  This class handles the skill/item hotkey processing.
#  The position of the arrow has been changed to the bottom of the screen.
#  Also included the upside down arrow.
#==============================================================================

class Scene_Hotkeys
 
  #----------------------------------------------------------------------------
  # main
  #  The main processing method.
  #----------------------------------------------------------------------------
  def main
    # create spriteset
    @spriteset = Spriteset_Map.new
    # create viewport
    @view = Viewport.new(0, 0, 640, 480)
    # set tone to current screen tone
    @view.tone = @tone.clone
    # create HUD if HUD is turned on and HUD active
    @hud = Hud.new if BlizzABS::Config::HUD_ENABLED && $game_system.hud
    # if ASSIGNMENT is turned
    if BlizzABS::Config::HOTKEYS
      # create assignment display
      @hotkeys = Hotkey_Assignment.new
      # set z position
      @hotkeys.z = 5000
    end
    # create sprite
    @choice = Sprite.new
    # create bitmap
    @choice.bitmap = menu_arrow
    # set x, y and z positions
    @choice.x, @choice.y, @choice.z, @choice.opacity = 160, 430, 500, 128
    # set x position offset
    @choice.ox = -8
    # set active flag
    @active = true
    # set index
    @index = 0
    # set up mode flag
    @up_mode = true
    # create modified skill window
    @skill_window = Window_Skill_Hotkey.new($game_player.battler)
    # create modified item window
    @item_window = Window_Item_Hotkey.new
    # set last active
    @last_active = true
    # transtition
    Graphics.transition
    # loop
    loop do
      # update game screen
      Graphics.update
      # update input
      Input.update
      # frame update
      update
      # stop if chosen an option
      break if $scene != self
    end
    # freeze screen
    Graphics.freeze
    # delet spriteset
    @spriteset.dispose
    # delete HUD elements that exist
    [@hud, @hotkeys, @minimap].each {|s| s.dispose if s != nil}
    # delete choice sprite
    @choice.dispose
    # delete skill window
    @skill_window.dispose
    # delete item window
    @item_window.dispose
    # delete viewport
    @view.dispose
  end
  #--------------------------------------------------------------------------
  # menu_arrow
  #  Creates the arrow displayed in the hotkey assignment menu.  Upside down
  #--------------------------------------------------------------------------
  def menu_arrow
    b = Bitmap.new(16, 9)
    c1 = Color.new(0, 0, 0)
    c2 = Color.new(255, 255, 255)
    c3 = Color.new(127, 127, 127)
    b.fill_rect(7, 8, 2, 1, c2)
    b.set_pixel(6, 7, c2)
    b.fill_rect(7, 7, 1, 7, c3)
    b.fill_rect(8, 7, 1, 7, c1)
    b.set_pixel(9, 7, c2)
    b.set_pixel(5, 6, c2)
    b.fill_rect(6, 6, 1, 6, c3)
    b.fill_rect(9, 6, 1, 6, c1)
    b.set_pixel(10, 6, c2)
    b.set_pixel(4, 5, c2)
    b.fill_rect(5, 5, 1, 5, c3)
    b.fill_rect(10, 5, 1, 5, c1)
    b.set_pixel(11, 5, c2)
    b.set_pixel(3, 4, c2)
    b.fill_rect(4, 4, 1, 4, c3)
    b.fill_rect(11, 4, 1, 4, c1)
    b.set_pixel(12, 4, c2)
    b.set_pixel(2, 3, c2)
    b.fill_rect(3, 3, 1, 3, c3)
    b.fill_rect(12, 3, 1, 3, c1)
    b.set_pixel(13, 3, c2)
    b.set_pixel(1, 2, c2)
    b.fill_rect(2, 2, 1, 2, c3)
    b.fill_rect(13, 2, 1, 2, c1)
    b.set_pixel(14, 2, c2)
    b.set_pixel(0, 1, c2)
    b.set_pixel(1, 1, c3)
    b.set_pixel(14, 1, c1)
    b.set_pixel(15, 1, c2)
    b.fill_rect(1, 0, 14, 1, c2)
    return b
  end
 
end

RoseSkye

Yeah there is an error

Script 'HUD' line 470: NoMethodError occured

undefined method `/' for nil:NilClass

Landith

You have it below Blizz-ABS Right..?

RoseSkye


Landith

That's an odd error... >.<
Did you copy it all..?

G_G

its cuz he probably has no members at the beginning of the game.

Landith

Oh... Well I haven't tested it fully yet so yeah... xD

RoseSkye

March 31, 2009, 08:42:00 pm #37 Last Edit: March 31, 2009, 08:45:48 pm by RoseSkye
Yep. I get the error as soon as I equip an hotkey'd skill.

Btw its too laggy I can't use it.

Landith

Odd, it doesn't happen for me.
What other scripts do you have..?

G_G

It could be laggy due to alot of processes opened sucking too much memory.