#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
# Blizz-ABS Party HUD by Winkio
# Version: 1.25
#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
#
#
#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
# This script modifies the Blizz-ABS HUD to display the HP/SP of up to ,six
# 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
#|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
#==============================================================================
# PARHUD_CONFIG
#------------------------------------------------------------------------------
# This module is the configuration section
#==============================================================================
module PARHUD_CONFIG
# Keeps health bar same color no matter what hp
COLOR_FIX = false
# Centers the hud display
CENTER_DISPLAY = true
# shows facesets. If set to true, must have a max party size of 4 or less.
# If set to false, must have a max party size of 6 or less.
FACESETS = true
# display map name in hud
MAPNAME = true
# background picture for top hud. If you have one, put it in Pictures.
# Set this variable to the file name, for example, "mybg.png"
# It should be 640 pixels wide and 50+TOPSPACE pixels tall.
BGTOP = "mybg.png"
# space between top of HUD and top of screen. must be between 0 and 14
TOPSPACE = 2
# allow minimap to be fullscreen
MINIMAP_FULLSCREEN = true
end
#==============================================================================
# Game_System
#------------------------------------------------------------------------------
# This class was modified to support the party hud
#==============================================================================
class Game_System
attr_accessor :parhud
alias initialize_parhud_later initialize
def initialize
@parhud = true
initialize_parhud_later
end
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, 50+PARHUD_CONFIG::TOPSPACE)
# set font
self.bitmap.font.name = 'Calibri'
# 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
test_offset
@hp, @maxhp = [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]
@sp, @maxsp = [0, 0, 0, 0, 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
@name_x, @name_y, @hp_x, @hp_y, @sp_x, @sp_y = [], [], [], [], [], []
if PARHUD_CONFIG::FACESETS
@face_x, @face_y = [], []
end
if !PARHUD_CONFIG::CENTER_DISPLAY
@maxpsize = BlizzABS::Config::MAX_PARTY
@name_x, @name_y, @hp_x, @hp_y, @sp_x, @sp_y = [], [], [], [], [], []
@face_x, @face_y = [], []
(0...@maxpsize).each {|i|
if PARHUD_CONFIG::FACESETS
xdat = i*640/@maxpsize + 320/@maxpsize-25
@face_x.push(xdat-52)
@face_y.push(PARHUD_CONFIG::TOPSPACE)
else
xdat = i*640/@maxpsize + 320/@maxpsize-50
end
@name_x.push(xdat)
@name_y.push(PARHUD_CONFIG::TOPSPACE)
@hp_x.push(xdat)
@hp_y.push(16+PARHUD_CONFIG::TOPSPACE)
@sp_x.push(xdat)
@sp_y.push(33+PARHUD_CONFIG::TOPSPACE)}
else
if (@psize == nil)
#@psize = 1
@psize = $game_party.actors.size
end
(0...@psize).each {|i|
if PARHUD_CONFIG::FACESETS
xdat = i*640/@psize + 320/@psize-25
@face_x.push(xdat-52)
@face_y.push(PARHUD_CONFIG::TOPSPACE)
else
xdat = i*640/@psize + 320/@psize-50
end
@name_x.push(xdat)
@name_y.push(PARHUD_CONFIG::TOPSPACE)
@hp_x.push(xdat)
@hp_y.push(16+PARHUD_CONFIG::TOPSPACE)
@sp_x.push(xdat)
@sp_y.push(33+PARHUD_CONFIG::TOPSPACE)}
end
end
#----------------------------------------------------------------------------
# draw_basic
# Draws the HUD template.
#----------------------------------------------------------------------------
def draw_basic
self.bitmap.font.size = 16
color = Color.new(255, 255, 255, 127)
if PARHUD_CONFIG::BGTOP != ""
# load bitmap
bitmap = RPG::Cache.picture(PARHUD_CONFIG::BGTOP)
# draw bitmap
self.bitmap.blt(0, 0, bitmap, Rect.new(0, 0, 640, 50+PARHUD_CONFIG::TOPSPACE))
end
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 and faces
self.bitmap.draw_text_full(@name_x[i], @name_y[i], 104, 20, actor(i).name, 1)
if PARHUD_CONFIG::FACESETS
self.bitmap.fill_rect(@face_x[i], @face_y[i], 50, 50, color)
# load bitmap
bitmap = RPG::Cache.picture("actor"+actor(i).id.to_s+".png")
# draw bitmap
self.bitmap.blt(@face_x[i]+1, @face_y[i]+1, bitmap, Rect.new(0, 0, 48, 48))
end
}
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)
if PARHUD_CONFIG::COLOR_FIX
# 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)
else
# draw gradient bar
self.bitmap.gradient_bar_hud(@hp_x[i], @hp_y[i], 100, rate, 'hud_green_bar', 1)
# set font color depending on how many HP left
self.bitmap.font.color = @hp[i] == 0 ? knockout_color :
@hp[i] <= @maxhp[i] / 4 ? crisis_color : normal_color
# draw HP
self.bitmap.draw_text_full(@hp_x[i]+1, @hp_y[i], 100, 11, @hp[i].to_s, 1)
self.bitmap.font.color = normal_color
end
}
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
self.bitmap.clear
create_positions
test_offset
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 actor(0).name != $game_actors[1].name
@poffset = (@poffset + 1) % @psize
else
return
end}
end
#----------------------------------------------------------------------------
# actor
# Returns the party leader's battler for easier reference.
#----------------------------------------------------------------------------
def actor(id = 0)
return $game_party.actors[(id + @poffset)%@psize]
end
#----------------------------------------------------------------------------
# dispose
# disposes of the sprite.
#----------------------------------------------------------------------------
def dispose
super
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 = 'Arial'
# 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 = 60, 120, 0, 420
@level_x, @level_y = 0, 0
@gold_x, @gold_y, @loc_x, @loc_y = 10, 20, 10, 40
@sbar_x, @sbar_y = 65, 60
if !BlizzABS::Config::DIRECT_HOTKEYS
@hot_x, @hot_y, @left_x, @left_y = 4, 60, 4, 74
end
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, 120, 14, color)
end
if !BlizzABS::Config::DIRECT_HOTKEYS
# draw "Skill:"
self.bitmap.draw_text_full(@hot_x, @hot_y, 48, 20, 'S')
# draw "Item:"
self.bitmap.draw_text_full(@hot_x+60, @hot_y, 48, 20, 'I')
end
# set font color
self.bitmap.font.color = system_color
# draw "ER"
self.bitmap.draw_text_full(@gold_x + 80, @gold_y, 20, 20, 'G')
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+1, 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, 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)
self.bitmap.font.size = 16
end
#----------------------------------------------------------------------------
# draw_gold
# Draws the gold display.
#----------------------------------------------------------------------------
def draw_gold
# set current variable
@gold = $game_party.gold
# remove old display
self.bitmap.fill_rect(@gold_x, @gold_y, 80, 20, Color.new(0, 0, 0, 127))
# set font color
self.bitmap.font.color = normal_color
# draw party's gold
self.bitmap.draw_text_full(@gold_x, @gold_y, 80, 20, $game_party.gold.to_s, 2)
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, 100, 20, Color.new(0, 0, 0, 127))
# set font color
self.bitmap.font.color = normal_color
# draw party's gold
self.bitmap.draw_text_full(@loc_x, @loc_y, 100, 20, $game_map.name, 1)
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+28, @hot_y+4, 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+28, @hot_y+4, 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, @left_y+4, 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, @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, @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 actor.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+88, @hot_y+4, 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+88, @hot_y+4, 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+4, 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_gold
if PARHUD_CONFIG::MAPNAME
draw_loc
end
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_gold
if PARHUD_CONFIG::MAPNAME
test_loc
end
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_gold
# Tests and draws the gold.
#----------------------------------------------------------------------------
def test_gold
# draw new er if er has changed
draw_gold if $game_party.gold != @gold
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
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(32, 320)
# 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 = 4, 60, 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(0, 32*(i-1), 32, 32, Color.new(0, 0, 0, 0))
# fill icon bachground
self.bitmap.fill_rect(4, 32*(i-1)+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(4, 32*(i-1)+4, bitmap, Rect.new(0, 0, 24, 24))
end
# draw hotkey number
self.bitmap.draw_text_full(2, 32*(i-1), 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
#==============================================================================
# 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) %
((PARHUD_CONFIG::MINIMAP_FULLSCREEN) ? 3 : 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 = 260, 416
# set y and z position
self.x, self.y, self.z = 60, 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 = 310, 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 = 200
end
# if MINIMAP is turned on and minimap active
if BlizzABS::Config::MINIMAP && $game_system.minimap > 0
# create HUD
@minimap = Minimap.new
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 = 4, 60, 500, 230
# 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
Show posts
