#===============================================================================
#
# Yanfly Engine Zealous - Weapon Mastery Skills
# Last Date Updated: 2010.01.22
# Level: Hard
#
# Weapon skills appear when certain weapons are equipped and after having used
# the said weapon enough times in battle. The weapon skills associated with the
# weapon are independent of what the user has learned through leveling or other
# means, but instead, dependent on how proficient the user is. Every single
# weapon can have different weapon skills even if they are the same weapon type
# thus, allowing the player a plethora of new options to explore when playing
# through the game.
#
#===============================================================================
# Updates
# -----------------------------------------------------------------------------
# o 2010.01.22 - Equipment Overhaul compatibility.
# o 2010.01.16 - Fixed up Weapon List Display.
# o 2010.01.13 - Barehand traits have now been added.
# o 2010.01.05 - Job System: Classes Compatibility.
# o 2009.12.30 - Skill Command Selection Compatibility.
# o 2009.12.28 - Bugfix regarding enemy attack.
# o 2009.12.27 - Finished script.
# o 2009.12.26 - Started script.
#===============================================================================
# Instructions
# -----------------------------------------------------------------------------
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# Weapon Tags - Insert the following tags into Weapon noteboxes.
# -----------------------------------------------------------------------------
#
# This is the first part of the necessary tags used for the script. The n value
# determines which weapon element to determine the mastery level of the weapon
# being used.
#
#
# At weapon mastery level n, skill m appears. These are both integers. To add
# more skills, add more of these tags within the same weapon notebox. Note that
# this tag requires the tag to be present in the same notebox
# in order for it to have any effect.
#
#
# This will make the weapon count as a barehanded weapon. However, it will not
# use the skills taken from empty weapon, but instead, it'll use its own weapon
# skill list so be sure to fill out the skill list accordingly.
#
# -----------------------------------------------------------------------------
# State Tags - Insert the following tags into State noteboxes.
# -----------------------------------------------------------------------------
# or
# The first tag causes all weapon exp rates to change to m% rate. If m is 200,
# then weapon exp is gained at 200%. If the second tag is used, only the weapon
# type n will be affected. n is the ID of the weapon type element.
#
# or
# If this tag is used, weapon level is raised/lowered by n amount. This is not
# a permanent change, but rather, a temporary change until the state wears off.
# This tag affects all weapons. This effect is stackable.
#
# or
# Just like the above tag, this adjusts the weapon level temporarily. However,
# it will only affect weapon element type m. This effect is stackable.
#
#
# If this state is inside of a state's tag, that actor will have the barehanded
# trait given to it. Note that this will only affect actors and not enemies
# because enemies cannot equip weapons and armours for obvious reasons. Also
# note that the actor must also not have any weapon equipped with the barehand
# elements.
#
# -----------------------------------------------------------------------------
# Debug Shortcuts - Only during $TEST and $BTEST mode
# -----------------------------------------------------------------------------
# During testplay mode, pressing F8 inside of the weapon mastery scene will
# raise the weapon experience of the currently equipped weapon. F7 will lower
# it. F6 will raise all weapon experience. F5 will lower all weapon experience.
#
#===============================================================================
# Compatibility
# -----------------------------------------------------------------------------
# - Works With: YEZ Battle Engine Zealous, YEZ Custom Status Properties,
# YEZ Custom Damage Control
# -----------------------------------------------------------------------------
# Note: This script may not work with former Yanfly Engine ReDux scripts.
# Use Yanfly Engine Zealous scripts to work with this if available.
#===============================================================================

$imported = {} if $imported == nil
$imported["WeaponMasterySkills"] = true

module YEZ
module WEAPON_MASTERY

#===========================================================================
# Basic Settings
# -------------------------------------------------------------------------
# Adjust the following settings below to fit the script to match the demands
# of your game. The very settings below dictate the basic visual aspects
# you wish to show your players.
#===========================================================================

# These two items adjust how the mastery command appears in your menus.
TITLE = "Maîtrise"
ICON = 26

# This determines whether or not you wish for the Mastery menu to appear
# in the main menu. If either Main Menu Zealous or Status Command Menu
# calls for the Mastery scene, this will be ignored.
DISPLAY_MENU = true

# The following is an array containing which elements will be accounted
# for weapon elements. Any elements that do not appear here, even if they
# appear in the class arrays below, will not be accounted for when gaining
# weapon experience.
ELEMENTS = [40..51]

# The following will only show which classes will have which weapon elements
# shown inside of the Weaponry window. If a class ID is unlisted, it will
# show the elements from class ID 0. That said, do not remove class ID 0.
CLASS_ELEMENTS ={
# ID => [Element List]
2 => [40,42,44,45,46,50,51], # Guerrier ( Deïl )
3 => [43,44,45,46,48,51], #Voleuse ( Dalana )
4 => [47,51], #Mage blanc ( Adalia )
5 => [40,41,42,44,45,46,49,50,51], #Guerrier Blanc ( Ikar )
6 => [40,47,51], #Mage Noir ( Rey )
7 => [44,45,46,47,51], #Invocatrice ( Deilia )
8 => [40,42,44,45,46,49,51], #Guerrier noir ( Shikyo )
9 => [44,45,46,47,51], #Mage Rouge ( Ylvia )
10 => [40,41,42,43,44,45,46,48,49,50,51], #Guerriere ( Ulria )

} # Do not remove this.

ICONS ={ # Element 0 will be the icon used for unlisted weapon elements.
# EleID => Icon
40 => 305, # Epée
41 => 704, # Lance
42 => 880, # Hache
43 => 560, # Dague
44 => 1312, # Arc
45 => 1336, # Arbalète
46 => 1472, # Pistolet
47 => 1073, # Baton
48 => 2785, # Pugilat
49 => 1639, # Marteau
50 => 9, # Sabre
51 => 11, # Main Nues
} # Do not remove this.

# This determines the font size used for the information displayed within
# the weapon mastery scene.
FONT_SIZE = 16

# This is the vocabulary used to govern all the instances of text inside
# of the weapon mastery scene.
VOCAB ={
# :method => Vocab
:header => "Maîtrise de %s",
:level => "LV%s",
:skills => "Maîtrise des Armes",
:srank => "S",
:arank => "A",
:brank => "B",
:crank => "C",
:drank => "D",
:erank => "E",
:frank => "F",
} # Do not remove this.

# This array determines what colours are used for which skill level ranks
# inside of the mastery window. The mastery rates are adjusted below under
# the class settings portion of the module.
RANK_COLOUR ={
:srank => 2,
:arank => 2,
:brank => 14,
:crank => 6,
:drank => 3,
:erank => 4,
:frank => 5,
} # Do not remove this.

# The following values determine the gauge colours used for the weapon
# experience completion bars.
WEXP_GAUGE0 = 19
WEXP_GAUGE1 = 30
WEXP_GAUGE2 = 31

#===========================================================================
# Class Settings
# -------------------------------------------------------------------------
# The following settings adjust the skill proficiency rate for each class.
# Set up the skill proficiency amounts and their rates. Then, match up the
# class rates with the proper element ranks.
#===========================================================================

# The following adjusts the exp gain rate for each rank. The rank determines
# what rate each class will learn weapon skills at. A value of 1.00 means
# the class will earn 100% experience. 3.00 means the class will learn at
# 300% experience. It's as simple as that.
S = 2.00
A = 1.50
B = 1.25
C = 1.00
D = 0.75
E = 0.50
F = 0.25

# The following hash determines what rank each class will gain weapon exp
# at. Note that if you have more than 10 weapon ranks, increase the size
# of the arrays below to match the size of the number of elements used.
PROFICIENCY = { # Do not remove class 0 for it is used for unlisted classes.
# ClassID => [Hnd, Swd, Axe, Ham, Dag, Spr, Scy, Bow, Gun, Mag]
# 02 => [ B, A, S, S, D, A, B, E, E, F], # Warrior
# 03 => [ D, D, E, B, D, C, D, B, C, A], # Priest
# 04 => [ D, D, E, F, C, C, C, A, C, S], # Magician
# 05 => [ E, A, C, C, E, D, D, F, F, B], # Paladin
# 06 => [ E, B, C, C, D, C, S, F, F, C], # D.Knight
# 07 => [ S, D, E, E, B, D, E, F, F, F], # Grappler
# 08 => [ C, D, D, F, S, F, D, D, S, F], # Thief

2=> [C , C, C, C, C, C, C], # Guerrier ( Deïl )
3 => [C, C, C, C, C, C], #Voleuse ( Dalana )
4 => [C, C], #Mage blanc ( Adalia )
5 => [C, C, C, C, C, C, C, C, C], #Guerrier Blanc ( Ikar )
6 => [C, C, C], #Mage Noir ( Rey )
7 => [C, C, C, C, C], #Invocatrice ( Deilia )
8 => [C, C, C, C, C, C, C, C], #Guerrier noir ( Shikyo )
9 => [C, C, C, C, C], #Mage Rouge ( Ylvia )
10 => [C, C, C, C, C, C, C, C, C, C, C], #Guerriere ( Ulria )

} # Do not remove this.

#===========================================================================
# Barehand Settings
# -------------------------------------------------------------------------
# When an actor has the barehand trait, that actor will deal more damage if
# unarmed without a weapon. Although some weapons can still give barehand
# bonuses, these actors and classes will have them by default.
#===========================================================================

# This is the element associated with being barehanded. Make sure it has an
# element from the above ELEMENTS array if you want barehanded actors to be
# able to have weapon skills. Note that if no weapons are equipped, this
# element set will be used, too, but the actor will not necessarily have
# the barehanded trait.
BAREHAND_ELEMENT = [1]

# This array adjusts the actors that will automatically benefit from having
# the barehand trait regardless of what class they have equipped.
BAREHAND_ACTORS = []

# This array adjusts which classes will benefit from having barehand traits
# regardless of which actor they are. Adjust the SUBCLASS_BAREHAND constant
# if you're using Job System: Classes.
BAREHAND_CLASSES = [10]
SUBCLASS_BAREHAND = true

# The following adjusts the barehand ATK multiplier formula. adjust it to
# gain the stat boost results you want for your barehanded multiplier.
BAREHAND_FORMULA = "[base_atk * (1.5 + @level * 0.15), base_atk + 400].min"

# When no weapon is equipped regardless of having a barehand trait or not,
# there can be weapon skills associated with having no weapon at all. Adjust
# the following hash to determine which weapon ID to draw weapon skill data
# from within the database. Note that the level mentioned is the actor's.
BAREHAND_WEAPON_SKILLS ={
# Level => Weapon ID
1 => 1, # Draw weapon skill data from weapon 1.
10 => 2, # Draw weapon skill data from weapon 2.
20 => 3, # Draw weapon skill data from weapon 3.
30 => 4, # Draw weapon skill data from weapon 4.
40 => 5, # Draw weapon skill data from weapon 5.
} # Do not remove this.

#===========================================================================
# Battle Settings
# -------------------------------------------------------------------------
# Adjust the following settings below to fit the script to match the demands
# of your game. These settings determine how weapon skills affect the battle
# system and menu system in your game.
#===========================================================================

# If this is set to true, weapon skills won't appear in the skill menu
# inside of battle, but instead, appear in a new menu when selected Attack.
REPLACE_ATTACK = true

# This determines the typical WEXP gain per attack and per skill action.
# If an attack has the attack or skill has the element in their attack set,
# then WEXP is earned.
WEXP = 10

# The following hash determines how much WEXP is needed for each level of
# weapon mastery. These rates will be static for all classes. This also
# determines the bonus damage multipliers applied to your weapons after
# they reached certain levels. These multipliers will only apply to the
# skills if they're in an actor's weapon skills.
WLVL ={ # Make sure level 0 requires only 0 WEXP.
# WLVL => [Dmg Mod, WEXP],
0 => [ 1.00, 0],
1 => [ 1.05, 35],
2 => [ 1.10, 75],
3 => [ 1.15, 113],
4 => [ 1.20, 169],
5 => [ 1.25, 253],
6 => [ 1.30, 380],
7 => [ 1.35, 570],
8 => [ 1.40, 854],
9 => [ 1.45, 1281],
10 => [ 1.50, 1922],
11 => [ 1.60, 2883],
12 => [ 1.70, 4325],
13 => [ 1.80, 6487],
14 => [ 1.90, 9731],
15 => [ 2.00, 14596],
} # Do not remove this.

end # WEAPON_MASTERY
end # YEZ

#===============================================================================
# Editting anything past this point may potentially result in causing computer
# damage, incontinence, explosion of user's head, coma, death, and/or halitosis.
# Therefore, edit at your own risk.
#===============================================================================

module YEZ::WEAPON_MASTERY
module_function
#--------------------------------------------------------------------------
# convert_integer_array
#--------------------------------------------------------------------------
def convert_integer_array(array)
result = []
array.each { |i|
case i
when Range; result |= i.to_a
when Integer; result |= [i]
end }
return result
end
#--------------------------------------------------------------------------
# full_convert_hash
#--------------------------------------------------------------------------
def full_convert_hash(hash)
result = {}
hash.each { |key|
result[key[0]] = convert_integer_array(key[1]) }
return result
end
#--------------------------------------------------------------------------
# converted lists
#--------------------------------------------------------------------------
ELEMENT_LIST = convert_integer_array(ELEMENTS)
CLASS_ELEMENT_LIST = full_convert_hash(CLASS_ELEMENTS)
BAREHAND_ELEMENT_LIST = convert_integer_array(BAREHAND_ELEMENT)
BAREHAND_ACTOR_LIST = convert_integer_array(BAREHAND_ACTORS)
BAREHAND_CLASS_LIST = convert_integer_array(BAREHAND_CLASSES)
WLVL[0] = [1.00, 0]
end # YEZ::WEAPON_MASTERY

module YEZ
module REGEXP
module WEAPON

W_TYPE = /<(?:WEAPON_TYPE|weapon type):[ ](\d+)>/i
W_SKILL = /<(?:WEAPON_SKILL|weapon skill)[ ](?:LEVEL|lvl|lv)[ ](\d+):[ ]*(\d+)>/i
TRAITS = /<(?:TRAITS|trait):[ ](.*)>/i

end # WEAPON
module STATE

WEXP_RATE_ALL = /<(?:WEAPON_EXP|weapon exp|wexp)[ ](\d+)([%％])>/i
WEXP_RATE_ONE = /<(?:WEAPON_EXP|weapon exp|wexp)[ ](\d+):[ ]*(\d+)([%％])>/i
WLVL_SET_ALL = /<(?:WEAPON_LEVEL|weapon level|wlvl)[ ]([\+\-]\d+)>/i
WLVL_SET_ONE = /<(?:WEAPON_LEVEL|weapon level|wlvl)[ ](\d+):[ ]*([\+\-]\d+)>/i
TRAITS = /<(?:TRAITS|trait):[ ](.*)>/i

end # STATE
end # REGEXP
end # YEZ

#===============================================================================
# RPG::Weapon
#===============================================================================

class RPG::Weapon

#--------------------------------------------------------------------------
# common cache: yez_cache_weapon_wms
#--------------------------------------------------------------------------
def yez_cache_weapon_wms
@weapon_type = 0; @weapon_skills = {}; @traits = []

self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YEZ::REGEXP::WEAPON::W_TYPE
@weapon_type = $1.to_i
when YEZ::REGEXP::WEAPON::W_SKILL
@weapon_skills[$1.to_i] = [] if @weapon_skills[$1.to_i] == nil
@weapon_skills[$1.to_i].push($2.to_i)
#---
when YEZ::REGEXP::WEAPON::TRAITS
@traits.push($1.upcase)
#---
end
} # end self.note.split
end # yez_cache_weapon_wms

#--------------------------------------------------------------------------
# new method: weapon_type
#--------------------------------------------------------------------------
def weapon_type
yez_cache_weapon_wms if @weapon_type == nil
return @weapon_type
end

#--------------------------------------------------------------------------
# new method: weapon_skills
#--------------------------------------------------------------------------
def weapon_skills
yez_cache_weapon_wms if @weapon_skills == nil
return @weapon_skills
end

#--------------------------------------------------------------------------
# new method: traits
#--------------------------------------------------------------------------
def traits
yez_cache_weapon_wms if @traits == nil
return @traits
end

end # RPG::Weapon

#===============================================================================
# RPG::State
#===============================================================================

class RPG::State

#--------------------------------------------------------------------------
# common cache: yez_cache_state_wms
#--------------------------------------------------------------------------
def yez_cache_state_wms
@wexp_rate = { 0 => 0 }; @wlvl_set = { 0 => 0 }; @traits = [];
for i in YEZ::WEAPON_MASTERY::ELEMENT_LIST; @wexp_rate[i] = 100; end
for i in YEZ::WEAPON_MASTERY::ELEMENT_LIST; @wlvl_set[i] = 0; end

self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YEZ::REGEXP::STATE::WEXP_RATE_ALL
for i in YEZ::WEAPON_MASTERY::ELEMENT_LIST; @wexp_rate[i] = $1.to_i; end
when YEZ::REGEXP::STATE::WEXP_RATE_ONE
@wexp_rate[$1.to_i] = $2.to_i
#---
when YEZ::REGEXP::STATE::WLVL_SET_ALL
for i in YEZ::WEAPON_MASTERY::ELEMENT_LIST; @wlvl_set[i] = $1.to_i; end
when YEZ::REGEXP::STATE::WLVL_SET_ONE
@wlvl_set[$1.to_i] = $2.to_i
#---
when YEZ::REGEXP::STATE::TRAITS
@traits.push($1.upcase)
#---
end
} # end self.note.split
end # yez_cache_state_wms

#--------------------------------------------------------------------------
# new method: wexp_rate
#--------------------------------------------------------------------------
def wexp_rate
yez_cache_state_wms if @wexp_rate == nil
return @wexp_rate
end

#--------------------------------------------------------------------------
# new method: wlvl_set
#--------------------------------------------------------------------------
def wlvl_set
yez_cache_state_wms if @wlvl_set == nil
return @wlvl_set
end

#--------------------------------------------------------------------------
# new method: traits
#--------------------------------------------------------------------------
def traits
yez_cache_state_wms if @traits == nil
return @traits
end

end # RPG::State

#===============================================================================
# Game_Battler
#===============================================================================

class Game_Battler

#--------------------------------------------------------------------------
# alias method: attack_effect
#--------------------------------------------------------------------------
alias attack_effect_wms attack_effect unless $@
def attack_effect(attacker)
attack_effect_wms(attacker)
if !@skipped and attacker.actor?
for i in attacker.weapon_types
next unless YEZ::WEAPON_MASTERY::ELEMENT_LIST.include?(i)
n = Integer(YEZ::WEAPON_MASTERY::WEXP * attacker.wexp_rate(i))
for state in attacker.states; n *= state.wexp_rate[i] / 100.0; end
attacker.gain_weapon_exp(i, [Integer(n), 0].max)
end
end
end

#--------------------------------------------------------------------------
# alias method: skill_effect
#--------------------------------------------------------------------------
alias skill_effect_wms skill_effect unless $@
def skill_effect(user, skill)
skill_effect_wms(user, skill)
user.gain_wexp(skill) unless @skipped
end

#--------------------------------------------------------------------------
# new method: gain_wexp
#--------------------------------------------------------------------------
def gain_wexp(skill)
return if skill == nil
return unless actor?
if earn_wexp?(skill)
for i in self.weapon_types
next unless YEZ::WEAPON_MASTERY::ELEMENT_LIST.include?(i)
n = Integer(YEZ::WEAPON_MASTERY::WEXP * wexp_rate(i))
for state in states; n *= state.wexp_rate[i] / 100.0; end
self.gain_weapon_exp(i, [Integer(n), 0].max)
end
end
end

#--------------------------------------------------------------------------
# new method: earn_wexp?
#--------------------------------------------------------------------------
def earn_wexp?(skill)
return true if self.weapon_skills(true).include?(skill)
element_set = skill.element_set
element_set += self.element_set if skill.physical_attack
for i in element_set
return true if YEZ::WEAPON_MASTERY::ELEMENT_LIST.include?(i) and
self.weapon_types.include?(i)
end
return false
end

#--------------------------------------------------------------------------
# alias method: make_obj_damage_value
#--------------------------------------------------------------------------
unless $imported["CustomDamageControl"]
alias make_obj_damage_value_wms make_obj_damage_value unless $@
def make_obj_damage_value(user, obj)
make_obj_damage_value_wms(user, obj)
if obj.damage_to_mp
@mp_damage = user.weapon_skill_multiplier(obj, @mp_damage)
else
@hp_damage = user.weapon_skill_multiplier(obj, @hp_damage)
end
end
end

#--------------------------------------------------------------------------
# new method: weapon_skill_multiplier
#--------------------------------------------------------------------------
def weapon_skill_multiplier(obj, damage)
return damage unless self.actor?
return damage unless obj.is_a?(RPG::Skill)
return damage unless self.weapon_skills.include?(obj)
for id in weapon_types
damage *= YEZ::WEAPON_MASTERY::WLVL[weapon_level(id)][0]; break
end
return Integer(damage)
end

end # Game_Battler

#===============================================================================
# Game_Actor
#===============================================================================

class Game_Actor < Game_Battler

#--------------------------------------------------------------------------
# alias method: setup
#--------------------------------------------------------------------------
alias setup_game_actor_wms setup unless $@
def setup(actor_id)
setup_game_actor_wms(actor_id)
@weapon_mastery = nil; weapon_mastery
end

#--------------------------------------------------------------------------
# alias method: skills
#--------------------------------------------------------------------------
unless $imported["JobSystemClasses"]
alias skills_wms skills unless $@
def skills
if include_weapon_skills?
result = skills_wms + weapon_skills
result.sort! { |a,b| a.id <=> b.id }
return result
else
return skills_wms
end
end
end

#--------------------------------------------------------------------------
# new method: include_weapon_skills?
#--------------------------------------------------------------------------
def include_weapon_skills?
return true unless YEZ::WEAPON_MASTERY::REPLACE_ATTACK
return true if $scene.is_a?(Scene_Skill)
return true if $scene.is_a?(Scene_Status)
return false
end


#--------------------------------------------------------------------------
# overwrite method: skill_can_use?
#--------------------------------------------------------------------------
def skill_can_use?(skill)
return super
end

#--------------------------------------------------------------------------
# new method: weapon_mastery
#--------------------------------------------------------------------------
def weapon_mastery
if @weapon_mastery == nil
@weapon_mastery = {}
for i in YEZ::WEAPON_MASTERY::ELEMENT_LIST
@weapon_mastery[i] = 0
end
end
return @weapon_mastery
end

#--------------------------------------------------------------------------
# new method: gain_weapon_exp
#--------------------------------------------------------------------------
def gain_weapon_exp(weapon_id, exp)
return unless YEZ::WEAPON_MASTERY::ELEMENT_LIST.include?(weapon_id)
@weapon_mastery[weapon_id] = 0 if @weapon_mastery[weapon_id] == nil
@weapon_mastery[weapon_id] += exp
@weapon_mastery[weapon_id] = [@weapon_mastery[weapon_id], 0].max
end

#--------------------------------------------------------------------------
# new method: wexp_rate
#--------------------------------------------------------------------------
def wexp_rate(ele_id)
position = nil
for i in 0..YEZ::WEAPON_MASTERY::ELEMENT_LIST.size
position = i if ele_id == YEZ::WEAPON_MASTERY::ELEMENT_LIST[i]
end
if YEZ::WEAPON_MASTERY::PROFICIENCY.include?(@class_id)
rate_array = YEZ::WEAPON_MASTERY::PROFICIENCY[@class_id]
else
rate_array = YEZ::WEAPON_MASTERY::PROFICIENCY[0]
end
return YEZ::WEAPON_MASTERY::C if position + 1 > rate_array.size
rate = rate_array[position]
return rate
end

#--------------------------------------------------------------------------
# new method: weapon_level
#--------------------------------------------------------------------------
def weapon_level(ele_id)
n = 0
for i in 0..(YEZ::WEAPON_MASTERY::WLVL.size+1)
next unless YEZ::WEAPON_MASTERY::WLVL.include?(i)
next unless weapon_mastery.include?(ele_id)
n = i if weapon_mastery[ele_id] > YEZ::WEAPON_MASTERY::WLVL[i][1]
end
for state in states
if $imported["CustomStatusPropertiesZeal"]
for i in 1..stack(state); n += state.wlvl_set[ele_id]; end
else
n += state.wlvl_set[ele_id]
end
end
return [[n, YEZ::WEAPON_MASTERY::WLVL.max[0]].min, 0].max
end

#--------------------------------------------------------------------------
# new method: weapon_skills
#--------------------------------------------------------------------------
def weapon_skills(all = false)
result = []
if weapons.compact != []
for weapon in weapons.compact
next if weapon.weapon_type <= 0
ele_id = weapon.weapon_type
for i in 0..(YEZ::WEAPON_MASTERY::WLVL.size + 1)
break if (i > weapon_level(ele_id) and !all)
next if weapon.weapon_skills[i] == nil
for skill_id in weapon.weapon_skills[i]
skill = $data_skills[skill_id]
next if skill == nil
next if result.include?(skill)
result.push(skill)
end
end
break
end
else
current_level = 0
weapon = nil
for key in YEZ::WEAPON_MASTERY::BAREHAND_WEAPON_SKILLS
next if key[0] > @level
current_level = key[0] if key[0] >= current_level
next if current_level == 0
weapon_id = YEZ::WEAPON_MASTERY::BAREHAND_WEAPON_SKILLS[current_level]
weapon = $data_weapons[weapon_id]
end
if weapon != nil and weapon.weapon_type > 0
ele_id = weapon.weapon_type
for i in 0..(YEZ::WEAPON_MASTERY::WLVL.size + 1)
break if (i > weapon_level(ele_id) and !all)
next if weapon.weapon_skills[i] == nil
for skill_id in weapon.weapon_skills[i]
skill = $data_skills[skill_id]
next if skill == nil
next if result.include?(skill)
result.push(skill)
end
end
end
end
result.sort! { |a,b| a.id <=> b.id }
return result
end

#--------------------------------------------------------------------------
# new method: weapon_types
#--------------------------------------------------------------------------
def weapon_types
result = []
if weapons.compact != []
for weapon in weapons.compact
next if weapon.weapon_type <= 0
if YEZ::WEAPON_MASTERY::ELEMENT_LIST.include?(weapon.weapon_type)
result.push(weapon.weapon_type)
end
end
else
current_level = 0
weapon = nil
for key in YEZ::WEAPON_MASTERY::BAREHAND_WEAPON_SKILLS
next if key[0] > @level
current_level = key[0] if key[0] >= current_level
next if current_level == 0
weapon_id = YEZ::WEAPON_MASTERY::BAREHAND_WEAPON_SKILLS[current_level]
weapon = $data_weapons[weapon_id]
end
if weapon != nil and weapon.weapon_type > 0 and
YEZ::WEAPON_MASTERY::ELEMENT_LIST.include?(weapon.weapon_type)
result.push(weapon.weapon_type)
end
end
return result.uniq
end

#--------------------------------------------------------------------------
# new method: total_skills
#--------------------------------------------------------------------------
unless $imported["CustomSkillEffectsZeal"]
def total_skills
result = skills + weapon_skills
result.sort! { |a,b| a.id <=> b.id }
return result.uniq
end
end

#--------------------------------------------------------------------------
# new method: can_use_weapon_skills?
#--------------------------------------------------------------------------
def can_use_weapon_skills?
for skill in self.weapon_skills
next if skill == nil
return true if skill_can_use?(skill)
end
return false
end

#--------------------------------------------------------------------------
# alias method: base_atk
#--------------------------------------------------------------------------
unless $imported["EquipmentOverhaul"]
alias base_atk_wms base_atk unless $@
def base_atk
n = base_atk_wms
n = barehand_formula(n) if barehand?
return Integer(n)
end
end

#--------------------------------------------------------------------------
# new method: barehand_formula
#--------------------------------------------------------------------------
def barehand_formula(base_atk)
base_attack = eval(YEZ::WEAPON_MASTERY::BAREHAND_FORMULA)
return base_attack
end

#--------------------------------------------------------------------------
# new method: barehand?
#--------------------------------------------------------------------------
def barehand?
if weapons.compact != []
bare_ele = YEZ::WEAPON_MASTERY::BAREHAND_ELEMENT_LIST
traits = ["BARE_HAND", "BARE HAND", "BAREHAND", "BAREHANDED"]
for weapon in weapons.compact
return true if (weapon.traits & traits) != []
return true if (weapon.element_set & bare_ele) == bare_ele and
base_barehand?
end
return false
end
return base_barehand?
end

#--------------------------------------------------------------------------
# new method: base_barehand?
#--------------------------------------------------------------------------
def base_barehand?
return true if YEZ::WEAPON_MASTERY::BAREHAND_ACTOR_LIST.include?(id)
return true if YEZ::WEAPON_MASTERY::BAREHAND_CLASS_LIST.include?(@class_id)
if $imported["JobSystemClasses"] and subclass != nil and
YEZ::WEAPON_MASTERY::SUBCLASS_BAREHAND
return true if
YEZ::WEAPON_MASTERY::BAREHAND_CLASS_LIST.include?(@subclass_id)
end
traits = ["BARE_HAND", "BARE HAND", "BAREHAND", "BAREHANDED"]
for state in states; return true if (state.traits & traits) != []; end
return false
end

#--------------------------------------------------------------------------
# alias method: element_set
#--------------------------------------------------------------------------
alias element_set_wms element_set unless $@
def element_set
return YEZ::WEAPON_MASTERY::BAREHAND_ELEMENT_LIST if weapons.compact == []
return element_set_wms
end

end # Game_Actor

#===============================================================================
# Scene_Battle
#===============================================================================

class Scene_Battle < Scene_Base

#--------------------------------------------------------------------------
# alias method: update_actor_command_selection
#--------------------------------------------------------------------------
if YEZ::WEAPON_MASTERY::REPLACE_ATTACK
alias update_actor_cmd_selection_wms update_actor_command_selection unless $@
def update_actor_command_selection
if Input.trigger?(Input::C) and @actor_command_window.index == 0 and
@active_battler.can_use_weapon_skills?
Sound.play_decision
start_weapon_skill_selection
else
update_actor_cmd_selection_wms
end
end
end # YEZ::WEAPON_MASTERY::REPLACE_ATTACK

#--------------------------------------------------------------------------
# new method: start_weapon_skill_selection
#--------------------------------------------------------------------------
def start_weapon_skill_selection
@help_window = Window_Help.new
if $imported["BattleEngineZealous"] and @smaller_obj_window
@skill_window = Window_WeaponSkill.new(0, 288, 416, 128, @active_battler)
start_smaller_obj_window
else
@skill_window = Window_WeaponSkill.new(0, 56, 544, 232, @active_battler)
end
@skill_window.help_window = @help_window
@actor_command_window.active = false
end

end # Scene_Battle

#===============================================================================
# Scene Menu
#===============================================================================

class Scene_Menu < Scene_Base

#--------------------------------------------------------------------------
# alias method: create_command_window
#--------------------------------------------------------------------------
alias create_command_window_wms create_command_window unless $@
def create_command_window
create_command_window_wms
return if $imported["CustomMenuCommand"]
if YEZ::WEAPON_MASTERY::DISPLAY_MENU
wms_text = YEZ::WEAPON_MASTERY::TITLE
@command_mastery = @command_window.add_command(wms_text)
if @command_window.oy > 0
@command_window.oy -= Window_Base::WLH
end
end
@command_window.index = @menu_index
end

#--------------------------------------------------------------------------
# alias method: update_command_selection
#--------------------------------------------------------------------------
alias update_command_selection_wms update_command_selection unless $@
def update_command_selection
if Input.trigger?(Input::C)
case @command_window.index
when @command_mastery
if $game_party.members.size == 0
Sound.play_buzzer
return
end
Sound.play_decision
start_actor_selection
return
end
end
update_command_selection_wms
end

#--------------------------------------------------------------------------
# alias method: update_actor_selection
#--------------------------------------------------------------------------
alias update_actor_selection_wms update_actor_selection unless $@
def update_actor_selection
if Input.trigger?(Input::C)
$game_party.last_actor_index = @status_window.index
Sound.play_decision
case @command_window.index
when @command_mastery
$scene = Scene_Mastery.new(@status_window.index, @command_mastery)
return
end
end
update_actor_selection_wms
end

end # Scene Menu

#===============================================================================
# Scene_Mastery
#===============================================================================

class Scene_Mastery < Scene_Base

#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :actor

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor_index = 0, menu_index = 0)
@actor_index = actor_index
@menu_index = menu_index
end

#--------------------------------------------------------------------------
# start
#--------------------------------------------------------------------------
def start
super
create_menu_background
@actor = $game_party.members[@actor_index]
@help_window = Window_Help.new
@mastery_window = Window_Mastery.new(0, 56, @actor)
@mastery_list = Window_MasteryList.new(278, 80, @actor)
@mastery_list.help_window = @help_window
$game_party.last_actor_index = @actor_index
end

#--------------------------------------------------------------------------
# terminate
#--------------------------------------------------------------------------
def terminate
super
dispose_menu_background
@help_window.dispose if @help_window != nil
@mastery_window.dispose if @mastery_window != nil
@mastery_list.dispose if @mastery_list != nil
end

#--------------------------------------------------------------------------
# return_scene
#--------------------------------------------------------------------------
def return_scene
if $imported["StatusCommandMenu"] and $game_temp.status_index != nil
$scene = Scene_Status.new(@actor_index)
elsif $imported["SkillCommandSelection"] and $game_temp.scs_on
$scene = Scene_Skill.new(@actor_index, @menu_index)
elsif $imported["EquipmentOverhaul"] and $game_temp.equip_last != nil
$scene = Scene_Equip.new(@actor_index)
elsif $imported["JobSystemClasses"] and $game_temp.jpc_oy != nil
$scene = Scene_Class.new(@actor_index, 0, @menu_index)
elsif $imported["CustomMenuCommand"] and
$game_temp.menu_command_index.has_key?(:mastery)
$scene = Scene_Menu.new($game_temp.menu_command_index[:mastery])
else
$scene = Scene_Menu.new(@menu_index)
end
end

#--------------------------------------------------------------------------
# next_actor
#--------------------------------------------------------------------------
def next_actor
@actor_index += 1
@actor_index %= $game_party.members.size
$scene = Scene_Mastery.new(@actor_index, @menu_index)
end

#--------------------------------------------------------------------------
# prev_actor
#--------------------------------------------------------------------------
def prev_actor
@actor_index += $game_party.members.size - 1
@actor_index %= $game_party.members.size
$scene = Scene_Mastery.new(@actor_index, @menu_index)
end

#--------------------------------------------------------------------------
# update
#--------------------------------------------------------------------------
def update
super
update_menu_background
@mastery_list.update
if Input.trigger?(Input::B)
Sound.play_cancel
return_scene

elsif $TEST and Input.repeat?(Input::F8) # Debug WEXP Increase
debug_weapon_mastery(@actor.weapon_types)
elsif $TEST and Input.repeat?(Input::F7) # Debug WEXP Decrease
debug_weapon_mastery(@actor.weapon_types, true)
elsif $TEST and Input.repeat?(Input::F6) # Debug WEXP Increase All
debug_weapon_mastery(YEZ::WEAPON_MASTERY::ELEMENT_LIST)
elsif $TEST and Input.repeat?(Input::F5) # Debug WEXP Decrease All
debug_weapon_mastery(YEZ::WEAPON_MASTERY::ELEMENT_LIST, true)

elsif Input.repeat?(Input::RIGHT) or (Input.repeat?(Input::R) and
@mastery_list.item_max.size < 11)
Sound.play_cursor
next_actor
elsif Input.repeat?(Input::LEFT) or (Input.repeat?(Input::L) and
@mastery_list.item_max.size < 11)
Sound.play_cursor
prev_actor
end
end

#--------------------------------------------------------------------------
# debug_weapon_mastery
#--------------------------------------------------------------------------
def debug_weapon_mastery(element_list, negative = false)
Sound.play_equip
for weapon_id in element_list
weapon_lvl1 = @actor.weapon_level(weapon_id)
weapon_lvl2 = [YEZ::WEAPON_MASTERY::WLVL.max[0], weapon_lvl1+1].min
value = YEZ::WEAPON_MASTERY::WLVL[weapon_lvl2][1]
value -= YEZ::WEAPON_MASTERY::WLVL[weapon_lvl1][1]
if weapon_lvl1 == weapon_lvl2
max = YEZ::WEAPON_MASTERY::WLVL.max[0]
value = YEZ::WEAPON_MASTERY::WLVL[max][1]
end
value /= 10 unless Input.press?(Input::SHIFT)
value += rand(value)
value *= -1 if negative
@actor.gain_weapon_exp(weapon_id, Integer(value))
end
@mastery_list.refresh
@mastery_window.refresh
end

end # Scene_Mastery

#===============================================================================
# Window_Command (imported from KGC)
#===============================================================================

class Window_Command < Window_Selectable
unless method_defined?(:add_command)
#--------------------------------------------------------------------------
# add command
#--------------------------------------------------------------------------
def add_command(command)
@commands << command
@item_max = @commands.size
item_index = @item_max - 1
refresh_command
draw_item(item_index)
return item_index
end
#--------------------------------------------------------------------------
# refresh command
#--------------------------------------------------------------------------
def refresh_command
buf = self.contents.clone
self.height = [self.height, row_max * WLH + 32].max
create_contents
self.contents.blt(0, 0, buf, buf.rect)
buf.dispose
end
#--------------------------------------------------------------------------
# insert command
#--------------------------------------------------------------------------
def insert_command(index, command)
@commands.insert(index, command)
@item_max = @commands.size
refresh_command
refresh
end
#--------------------------------------------------------------------------
# remove command
#--------------------------------------------------------------------------
def remove_command(command)
@commands.delete(command)
@item_max = @commands.size
refresh
end
end
end

#===============================================================================
# Window_Help
#===============================================================================

class Window_Help < Window_Base

#--------------------------------------------------------------------------
# alias method: current_actor
#--------------------------------------------------------------------------
if method_defined?(:current_actor)
alias current_actor_wms current_actor unless $@
def current_actor
if $scene.is_a?(Scene_Mastery)
return $scene.actor.name
else
return current_actor_wms
end
end
end

end # Window_Help

#===============================================================================
# Window_WeaponSkill
#===============================================================================

class Window_WeaponSkill < Window_Skill

#--------------------------------------------------------------------------
# overwrite method: refresh
#--------------------------------------------------------------------------
def refresh
@data = []
for skill in @actor.weapon_skills
next if $imported["CustomSkillEffectsZeal"] and !include?(skill)
@data.push(skill)
if skill.id == @actor.last_skill_id
self.index = @data.size - 1
end
end
@item_max = @data.size
create_contents
for i in 0...@item_max
draw_item(i)
end
end

end # Window_WeaponSkill

#===============================================================================
# Window_Mastery
#===============================================================================

class Window_Mastery < Window_Base

#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :weapon_list

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(x, y, actor, list = false)
super(x, y, 544 - x, 416 - y)
@actor = actor
refresh(list)
end

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh(list = false)
self.contents.clear
self.contents.font.size = Font.default_size
sw = self.width - 32
dy = 0
@weapon_list = []; results = []
class_element_list = YEZ::WEAPON_MASTERY::CLASS_ELEMENT_LIST

for weapon_id in YEZ::WEAPON_MASTERY::ELEMENT_LIST
if class_element_list.include?(@actor.class_id)
results = class_element_list[@actor.class_id]
else
results = class_element_list[0]
end
end
if $imported["JobSystemClasses"] and @actor.subclass != nil and
YEZ::JOB::SUBCLASS_WEAPONS
if class_element_list.include?(@actor.subclass_id)
results += class_element_list[@actor.subclass_id]
else
results += class_element_list[0]
end
end
for element_id in YEZ::WEAPON_MASTERY::ELEMENT_LIST
@weapon_list += [element_id] if results.include?(element_id)
end

vocab = YEZ::WEAPON_MASTERY::VOCAB
if self.height > 288 or @weapon_list.size < 10
self.contents.font.color = system_color
text = sprintf(vocab[:header], @actor.name)
self.contents.draw_text(48, dy, sw/2-48, WLH, text, 0)
text = vocab[:skills]
self.contents.draw_text(sw/2+24, dy, sw/2-24, WLH, text, 0)
dy += WLH
end
for ele_id in @weapon_list
self.contents.font.color = normal_color
self.contents.font.size = YEZ::WEAPON_MASTERY::FONT_SIZE
if @actor.weapon_level(ele_id) > 0
text = sprintf(vocab[:level], @actor.weapon_level(ele_id))
else
text = "-"
end
self.contents.draw_text(0, dy, 40, WLH, text, 2)
if YEZ::WEAPON_MASTERY::ICONS.include?(ele_id)
icon = YEZ::WEAPON_MASTERY::ICONS[ele_id]
else
icon = YEZ::WEAPON_MASTERY::ICONS[0]
end
draw_icon(icon, 48, dy)
draw_wexp_gauge(ele_id, 72, dy)
draw_rank(ele_id, 208, dy)
self.contents.font.color = normal_color
text = $data_system.elements[ele_id]
self.contents.draw_text(72, dy, 136, WLH, text, 0)
dy += WLH
end
dy = 0; dx = sw/2+22
dy += WLH if self.height > 288 or @weapon_list.size < 10
return unless list
for skill in @actor.weapon_skills(true)
self.contents.font.size = Font.default_size
enabled = @actor.weapon_skills.include?(skill)
draw_item_name(skill, dx, dy, enabled)
draw_skill_level(skill, dx + 196, dy, 34, enabled)
dy += WLH
end
end

#--------------------------------------------------------------------------
# draw_rank
#--------------------------------------------------------------------------
def draw_rank(ele_id, dx, dy)
rate = @actor.wexp_rate(ele_id)
if rate >= YEZ::WEAPON_MASTERY::S
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:srank]
text = YEZ::WEAPON_MASTERY::VOCAB[:srank]
elsif rate >= YEZ::WEAPON_MASTERY::A
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:arank]
text = YEZ::WEAPON_MASTERY::VOCAB[:arank]
elsif rate >= YEZ::WEAPON_MASTERY::B
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:brank]
text = YEZ::WEAPON_MASTERY::VOCAB[:brank]
elsif rate >= YEZ::WEAPON_MASTERY::C
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:crank]
text = YEZ::WEAPON_MASTERY::VOCAB[:crank]
elsif rate >= YEZ::WEAPON_MASTERY:
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:drank]
text = YEZ::WEAPON_MASTERY::VOCAB[:drank]
elsif rate >= YEZ::WEAPON_MASTERY::E
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:erank]
text = YEZ::WEAPON_MASTERY::VOCAB[:erank]
else
colour = YEZ::WEAPON_MASTERY::RANK_COLOUR[:frank]
text = YEZ::WEAPON_MASTERY::VOCAB[:frank]
end
self.contents.font.color = text_color(colour)
self.contents.draw_text(dx, dy, 34, WLH, text, 1)
end

#--------------------------------------------------------------------------
# draw_wexp_gauge
#--------------------------------------------------------------------------
def draw_wexp_gauge(ele_id, dx, dy, dw = 136)
wlvl = @actor.weapon_level(ele_id)
exp1 = @actor.weapon_mastery[ele_id] - YEZ::WEAPON_MASTERY::WLVL[wlvl][1]
if @actor.weapon_level(ele_id) != YEZ::WEAPON_MASTERY::WLVL.max[0]
exp2 = YEZ::WEAPON_MASTERY::WLVL[wlvl+1][1] -
YEZ::WEAPON_MASTERY::WLVL[wlvl][1]
else
exp2 = YEZ::WEAPON_MASTERY::WLVL[wlvl][1] -
YEZ::WEAPON_MASTERY::WLVL[wlvl][1]
end
gw = exp2 == 0 ? dw : [[dw * exp1 / exp2, dw].min, 0].max
gc0 = text_color(YEZ::WEAPON_MASTERY::WEXP_GAUGE0)
gc1 = text_color(YEZ::WEAPON_MASTERY::WEXP_GAUGE1)
gc2 = text_color(YEZ::WEAPON_MASTERY::WEXP_GAUGE2)
self.contents.fill_rect(dx, dy + WLH - 8, dw, 6, gc0)
self.contents.gradient_fill_rect(dx, dy + WLH - 8, gw, 6, gc1, gc2)
self.contents.draw_text(dx, dy, dw-2, WLH, @actor.weapon_mastery[ele_id], 2)
end

#--------------------------------------------------------------------------
# draw_skill_level
#--------------------------------------------------------------------------
def draw_skill_level(skill, dx, dy, dw, enabled = true)
self.contents.font.size = YEZ::WEAPON_MASTERY::FONT_SIZE
i = 0
for weapon in @actor.weapons.compact
for i in 0..(YEZ::WEAPON_MASTERY::WLVL.size+1)
next unless YEZ::WEAPON_MASTERY::WLVL.include?(i)
next unless weapon.weapon_skills.include?(i)
break if weapon.weapon_skills[i].include?(skill.id)
end
end
return if i <= 0
text = sprintf(YEZ::WEAPON_MASTERY::VOCAB[:level], i)
self.contents.draw_text(dx, dy, dw, WLH, text, 2)
end

end # Window_Mastery

#===============================================================================
# Window_MasteryList
#===============================================================================

class Window_MasteryList < Window_Selectable

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(dx, dy, actor)
super(dx, dy, 544 - dx, 272)
@actor = actor
@column_max = 1
self.opacity = 0
self.index = 0
refresh
end

#--------------------------------------------------------------------------
# skill
#--------------------------------------------------------------------------
def skill; return @data[self.index]; end

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
@data = []
for skill in @actor.weapon_skills(true)
@data.push(skill)
end
@item_max = @data.size
create_contents
for i in 0...@item_max
draw_item(i)
end
end

#--------------------------------------------------------------------------
# draw_item
#--------------------------------------------------------------------------
def draw_item(index)
rect = item_rect(index)
self.contents.clear_rect(rect)
self.contents.font.size = Font.default_size
skill = @data[index]
return if skill == nil
rect.width -= 4
enabled = @actor.weapon_skills.include?(skill)
draw_item_name(skill, rect.x, rect.y, enabled)
dw = rect.width - (rect.x + 196)
draw_skill_level(skill, rect.x + 196, rect.y, dw, enabled)
end

#--------------------------------------------------------------------------
# draw_skill_level
#--------------------------------------------------------------------------
def draw_skill_level(skill, dx, dy, dw, enabled = true)
self.contents.font.size = YEZ::WEAPON_MASTERY::FONT_SIZE
i = 0
for weapon in @actor.weapons.compact
for i in 0..(YEZ::WEAPON_MASTERY::WLVL.size+1)
next unless YEZ::WEAPON_MASTERY::WLVL.include?(i)
next unless weapon.weapon_skills.include?(i)
break if weapon.weapon_skills[i].include?(skill.id)
end
end
return if i <= 0
text = sprintf(YEZ::WEAPON_MASTERY::VOCAB[:level], i)
self.contents.draw_text(dx, dy, dw, WLH, text, 2)
end

#--------------------------------------------------------------------------
# update_help
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(skill == nil ? "" : skill.description)
end

end # Window_MasteryList

#===============================================================================
#
# END OF FILE
#
#===============================================================================

##################################################
# Mog Basic Menu Plus V 1.0 #
##################################################
# By Moghunter
# http://www.atelier-rgss.com
##################################################
#Menu padrão VX com adição de alguns extras, neste
#script você poderá trabalhar em cima dele e adaptá-lo
#facilmente ao seu jogo.
#-------------------------------------------------
##############
# Game_Actor #
##############
class Game_Actor < Game_Battler
def now_exp
return @exp - @exp_list[@level]
end
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end
###############
# Window_Base #
###############
class Window_Base < Window
def draw_actor_level_menu(actor, x, y)
self.contents.font.color = system_color
self.contents.draw_text(290, y, 32, WLH, Vocab::level_a)
self.contents.font.color = normal_color
self.contents.draw_text(x + 16, y, 24, WLH, actor.level, 2)
end
def draw_actor_class_menu(actor, x, y)
self.contents.font.color = normal_color
self.contents.draw_text(x, y, 85, WLH, "")
end
def exp_gauge_color1
return text_color(30)
end
def exp_gauge_color2
return text_color(31)
end
def draw_actor_exp_meter(actor, x, y, width = 100)
if actor.next_exp != 0
exp = actor.now_exp
else
exp = 1
end
gw = width * exp / [actor.next_exp, 1].max
gc1 = exp_gauge_color1
gc2 = exp_gauge_color2
self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 30, WLH, "Exp")
self.contents.font.color = normal_color
xr = x + width
self.contents.draw_text(xr - 60, y, 60, WLH, actor.next_rest_exp_s, 2)
end
end
#####################
# Window_MenuStatus #
#####################
class Window_MenuStatus < Window_Selectable
def initialize(x, y)
super(x, y, 384, 416)
refresh
self.active = false
self.index = -1
end
def refresh
self.contents.clear
@item_max = $game_party.members.size
for actor in $game_party.members
draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
x = 104
y = actor.index * 96 + WLH / 2
draw_actor_name(actor, x, y)
draw_actor_class_menu(actor, x + 120, y)
draw_actor_level_menu(actor, x + 200, y)
draw_actor_state(actor, x, y + WLH * 2)
draw_actor_hp(actor, x + 120, y + WLH * 1)
draw_actor_mp(actor, x + 120, y + WLH * 2)
draw_actor_exp_meter(actor, x , y + WLH * 1)
end
end
def update_cursor
if @index < 0
self.cursor_rect.empty
elsif @index < @item_max
self.cursor_rect.set(0, @index * 96, contents.width, 96)
elsif @index >= 100
self.cursor_rect.set(0, (@index - 100) * 96, contents.width, 96)
else
self.cursor_rect.set(0, 0, contents.width, @item_max * 96)
end
end
end
$mogscript = {} if $mogscript == nil
$mogscript["basic_menu_plus"] = true