Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
881 lines (776 sloc) 32.4 KB
#==============================================================================
#
# ¥ Yami Engine Symphony - Equipment Learning
# -- Last Updated: 2012.12.21
# -- Level: Easy
# -- Requires: n/a
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YES-EquipmentLearning"] = true
#==============================================================================
# ¥ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.12.21 - Add compatible method for YEA - Ace Equip Engine.
# 2012.12.09 - Fixed: Victory bugs.
# - Fixed: Major crash with more than one equipment.
# 2012.12.08 - Finished Script.
# 2012.12.05 - Started Script.
#
#==============================================================================
# ¥ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script provides a feature which allows actors to learn skills through
# their equipments by earning Ability Point (AP).
#
#==============================================================================
# ¥ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ¥ Materials/‘fÞ but above ¥ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# Skill Notetags - These notetags go in the skills notebox in the database.
# -----------------------------------------------------------------------------
# <el require: x>
# Changes requiring Ability Point (AP) to learn skill to x.
#
# -----------------------------------------------------------------------------
# Enemy Notetags - These notetags go in the enemy notebox in the database.
# -----------------------------------------------------------------------------
# <el gain: x>
# Changes gaining Ability Point (AP) from killing enemy to x.
#
# -----------------------------------------------------------------------------
# Actor Notetags - These notetags go in the actor notebox in the database.
# -----------------------------------------------------------------------------
# <el rate: x%>
# Changes Ability Point (AP) gaining rate to x percent.
#
# -----------------------------------------------------------------------------
# Class Notetags - These notetags go in the class notebox in the database.
# -----------------------------------------------------------------------------
# <el rate: x%>
# Changes Ability Point (AP) gaining rate to x percent.
#
# -----------------------------------------------------------------------------
# Weapon Notetags - These notetags go in the weapon notebox in the database.
# -----------------------------------------------------------------------------
# <el skill: x>
# Adds skill id x to weapon's learning skills pool.
#
# -----------------------------------------------------------------------------
# Armor Notetags - These notetags go in the armor notebox in the database.
# -----------------------------------------------------------------------------
# <el skill: x>
# Adds skill id x to armor's learning skills pool.
#
# -----------------------------------------------------------------------------
# Script Calls - These commands are used with script calls.
# -----------------------------------------------------------------------------
# $game_actors[x].el_gain(y)
# This will cause actor x to gain y amount of AP.
#
#==============================================================================
# ¥ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjustments.
#
#==============================================================================
#==============================================================================
# ¡ Configuration
#==============================================================================
module YES
module EQUIPMENT_LEARNING
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - General AP Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# This adjusts the way AP appears visually in your game. AP is the kind of
# point need to learn skill from Equipments.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ICON = 0 # Icon index used to represent AP.
VOCAB = "AP" # What AP will be called in your game.
# Below options are the Settings for Learning Window.
LEARN_TITLE = "Available Skills"
SHOW_GAUGE = true
COLOR_GAUGE = { # Start.
:color1 => 9,
:color2 => 1,
} # End.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Scenes Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# This adjusts the way Learning Skills appears in your game.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ENABLE_WINDOW = true # Enable Learning Window in Scene Equip.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Default AP Gain Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# The following constants adjust how much AP is earned by default through
# enemy kills, leveling up, and performing actions.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ENEMY_KILL = 10 # AP earned for the whole party.
LEVEL_UP = 100 # AP earned when leveling up!
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Default AP Required Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# The following constants adjust how much AP is required by default to learn
# skills from equipments.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
REQUIRE_AP = 100 # AP required for learning skill.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Victory Message -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# This adjusts the victory message shown for the default battle system and
# the Yanfly Engine Ace - Victory Aftermath script (if used together).
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
VICTORY_MESSAGE = "%s has earned %s %s!"
VICTORY_LEARN = "%s has learned new abilities!"
# Below options are compatible settings for YEA - Victory Aftermath
VICTORY_AFTERMATH = "+%s%s"
VICTORY_AFTERMATH_QUOTES = { # Start.
:el_learn => [ # Occurs when actor has learnt skills from Equipments.
'"I have mastered some skills from equipments!"',
'"Yeah! New skills!"',
],# Do not remove this.
} # End.
end
end
#==============================================================================
# ¥ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
#==============================================================================
# ¡ YEA - Victory Aftermath Compatible Area.
#==============================================================================
module YEA
module VICTORY_AFTERMATH
if $imported["YEA-VictoryAftermath"]
VICTORY_QUOTES.merge!(YES::EQUIPMENT_LEARNING::VICTORY_AFTERMATH_QUOTES)
end
end
end
#==============================================================================
# ¡ Regular Expression
#==============================================================================
module REGEXP
module EQUIPMENT_LEARNING
AP_RATE = /<(?:EL_RATE|el rate):[ ]*(\d+)(?:[%“])*>/i
AP_GAIN = /<(?:EL_GAIN|el gain):[ ]*(\d+)>/i
TEACH_SKILL = /<(?:EL_SKILL|el skill):[ ]*(\d+)>/i
TEACH_REQ = /<(?:EL_REQUIRE|el require):[ ]*(\d+)>/i
EL_QUOTE_ON = /<(?:EL_QUOTES|el quote|el quotes)>/i
EL_QUOTE_OFF = /<\/(?:EL_QUOTES|el quote|el quotes)>/i
end # EQUIPMENT_LEARNING
end # REGEXP
#==============================================================================
# ¡ BattleManager
#==============================================================================
module BattleManager
unless $imported["YEA-VictoryAftermath"]
#--------------------------------------------------------------------------
# alias method: display_exp
#--------------------------------------------------------------------------
class<< self; alias yes_equip_learning_display_exp display_exp; end
def self.display_exp
yes_equip_learning_display_exp
if $game_troop.elp_total > 0
text = ""
$game_party.all_members.each { |actor|
s = YES::EQUIPMENT_LEARNING::VICTORY_MESSAGE
name = actor.name
amount = ($game_troop.elp_total * actor.elr / 100).round
vocab = YES::EQUIPMENT_LEARNING::VOCAB
text += "\n" if text != ""
text += sprintf(s, name, amount.to_s, vocab)
}
$game_message.add('\.' + text)
end
end
#--------------------------------------------------------------------------
# alias method: gain_exp
#--------------------------------------------------------------------------
class<< self; alias yes_equip_learning_gain_exp gain_exp; end
def self.gain_exp
yes_equip_learning_gain_exp
$game_party.all_members.each { |actor|
result = actor.el_gain($game_troop.elp_total)
if result
$game_message.new_page
$game_message.add(sprintf(YES::EQUIPMENT_LEARNING::VICTORY_LEARN, actor.name))
result.uniq.each do |skill|
$game_message.add(sprintf(Vocab::ObtainSkill, skill.name))
end
end
}
wait_for_message
end
else
#--------------------------------------------------------------------------
# alias method: gain_exp
#--------------------------------------------------------------------------
class<< self; alias yes_equip_learning_gain_exp gain_exp; end
def self.gain_exp
@temp = {}
$game_party.all_members.each { |actor|
@temp[actor.object_id] = Marshal.load(Marshal.dump(actor))
}
yes_equip_learning_gain_exp
gain_el
end
#--------------------------------------------------------------------------
# new method: gain_el
#--------------------------------------------------------------------------
def self.gain_el
$game_party.all_members.each { |actor|
temp_actor = @temp[actor.object_id]
actor.el_gain($game_troop.elp_total)
next if actor.skills == temp_actor.skills
SceneManager.scene.show_victory_el_learn(actor, temp_actor)
set_victory_text(actor, :el_learn)
wait_for_message
}
end
end
end # BattleManager
#==============================================================================
# ¡ DataManager
#==============================================================================
module DataManager
#--------------------------------------------------------------------------
# alias method: load_database
#--------------------------------------------------------------------------
class <<self; alias load_database_equipment_learning load_database; end
def self.load_database
load_database_equipment_learning
initialize_equipment_learning
end
#--------------------------------------------------------------------------
# new method: initialize_equipment_learning
#--------------------------------------------------------------------------
def self.initialize_equipment_learning
groups = [$data_actors, $data_classes, $data_weapons, $data_armors,
$data_skills, $data_enemies, $data_items]
groups.each { |group|
group.each { |obj|
next if obj.nil?
obj.initialize_equipment_learning
}
}
end
end # DataManager
#==============================================================================
# ¡ RPG::BaseItem
#==============================================================================
class RPG::BaseItem
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :el_skills
attr_accessor :el_rate
attr_accessor :el_gain
attr_accessor :el_require
attr_accessor :el_quotes
#--------------------------------------------------------------------------
# new method: initialize_equipment_learning
#--------------------------------------------------------------------------
def initialize_equipment_learning
@el_quotes = [""]
@el_skills = []
@el_gain = self.is_a?(RPG::Item) ? 0 : YES::EQUIPMENT_LEARNING::ENEMY_KILL
@el_require = YES::EQUIPMENT_LEARNING::REQUIRE_AP
self.note.split(/[\r\n]+/).each { |line|
case line
when REGEXP::EQUIPMENT_LEARNING::AP_RATE
@el_rate = $1.to_i
when REGEXP::EQUIPMENT_LEARNING::AP_GAIN
@el_gain = $1.to_i
when REGEXP::EQUIPMENT_LEARNING::TEACH_SKILL
@el_skills.push($1.to_i)
when REGEXP::EQUIPMENT_LEARNING::TEACH_REQ
@el_require = $1.to_i
end
}
if $imported["YEA-VictoryAftermath"]
self.note.split(/[\r\n]+/).each { |line|
case line
when REGEXP::EQUIPMENT_LEARNING::EL_QUOTE_ON
@victory_quote_type = :el_quote
when REGEXP::EQUIPMENT_LEARNING::EL_QUOTE_OFF
@victory_quote_type = nil
#---
when YEA::REGEXP::BASEITEM::NEW_QUOTE
case @victory_quote_type
when nil; next
when :el_quote; @el_quotes.push("")
end
#---
else
case @victory_quote_type
when nil; next
when :el_quote; @el_quotes[@el_quote.size-1] += line.to_s
end
end
}
return unless self.is_a?(RPG::Class)
quotes = YEA::VICTORY_AFTERMATH::VICTORY_QUOTES
@el_quotes = quotes[:el_learn].clone if @el_quotes == [""]
end
end
end # RPG::BaseItem
#==============================================================================
# ¡ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# alias method: setup
#--------------------------------------------------------------------------
alias yes_equip_learning_setup setup
def setup(actor_id)
yes_equip_learning_setup(actor_id)
init_equip_learning
end
#--------------------------------------------------------------------------
# new method: init_equip_learning
#--------------------------------------------------------------------------
def init_equip_learning
@equip_learning ||= {}
end
#--------------------------------------------------------------------------
# new method: el_skills
#--------------------------------------------------------------------------
def el_skills
result = []
self.equips.each { |e|
next if e.nil?
e.el_skills.inject(result) { |r, i| r.push(i) }
}
result.compact.uniq
end
#--------------------------------------------------------------------------
# new method: elr
#--------------------------------------------------------------------------
def elr
[self.class.el_rate, self.actor.el_rate, 100].compact[0].to_f
end
#--------------------------------------------------------------------------
# new method: req_elp
#--------------------------------------------------------------------------
def req_elp(skill_id)
return 0 unless $data_skills[skill_id]
$data_skills[skill_id].el_require
end
#--------------------------------------------------------------------------
# new method: cur_elp
#--------------------------------------------------------------------------
def cur_elp(skill_id)
return 0 unless $data_skills[skill_id]
if skill_learn?($data_skills[skill_id])
r = req_elp(skill_id)
else
r = @equip_learning.has_key?(skill_id) ? @equip_learning[skill_id] : 0
end
return r
end
#--------------------------------------------------------------------------
# new method: fin_elp
#--------------------------------------------------------------------------
def fin_elp(skill_id)
return req_elp(skill_id) == cur_elp(skill_id)
end
#--------------------------------------------------------------------------
# new method: per_elp
#--------------------------------------------------------------------------
def per_elp(skill_id)
cur_elp(skill_id) / req_elp(skill_id).to_f
end
#--------------------------------------------------------------------------
# new method: el_gain
#--------------------------------------------------------------------------
def el_gain(amount = 0)
return unless self.el_skills.size > 0
return unless amount > 0
learn = []
point = (amount * elr / 100).round
self.el_skills.each { |id|
next unless $data_skills[id]
@equip_learning.has_key?(id) ? @equip_learning[id] += point : @equip_learning[id] = point
if @equip_learning[id] >= req_elp(id)
learn.push(id) unless skill_learn?($data_skills[id])
learn_skill(id)
@equip_learning[id] = req_elp(id)
end
}
return learn.size > 0 ? learn.collect { |id| $data_skills[id] } : false
end
#--------------------------------------------------------------------------
# alias method: level_up
#--------------------------------------------------------------------------
alias yes_equip_learning_level_up level_up
def level_up
yes_equip_learning_level_up
el_gain(YES::EQUIPMENT_LEARNING::LEVEL_UP)
end
#--------------------------------------------------------------------------
# alias method: victory_quotes
# Compatible with Yanfly Engine Ace - Victory Aftermath
#--------------------------------------------------------------------------
if $imported["YEA-VictoryAftermath"]
alias yes_equip_learning_victory_quotes victory_quotes
def victory_quotes(type)
case type
when :el_learn
return self.actor.el_quotes if self.actor.el_quotes != [""]
return self.class.el_quotes
else
return yes_equip_learning_victory_quotes(type)
end
end
end
end # Game_Actor
#==============================================================================
# ¡ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# new method: elp
#--------------------------------------------------------------------------
def elp
enemy.el_gain
end
end # Game_Enemy
#==============================================================================
# ¡ Game_Troop
#==============================================================================
class Game_Troop < Game_Unit
#--------------------------------------------------------------------------
# new method: elp_total
#--------------------------------------------------------------------------
def elp_total
dead_members.inject(0) {|r, enemy| r += enemy.elp }
end
end # Game_Troop
#==============================================================================
# ¡ Window_VictoryEXP_Back
#==============================================================================
class Window_VictoryEXP_Back < Window_Selectable
#--------------------------------------------------------------------------
# alias method: draw_exp_gain
# Compatible with Yanfly Engine Ace - Victory Aftermath
#--------------------------------------------------------------------------
if $imported["YEA-VictoryAftermath"]
alias yes_equip_learning_draw_exp_gain draw_exp_gain
def draw_exp_gain(actor, rect)
yes_equip_learning_draw_exp_gain(actor, rect)
draw_el_gain(actor, rect)
end
end
#--------------------------------------------------------------------------
# new method: draw_el_gain
# Compatible with Yanfly Engine Ace - Victory Aftermath
#--------------------------------------------------------------------------
def draw_el_gain(actor, rect)
dw = rect.width - (rect.width - [rect.width, 96].min) / 2
dy = rect.y + line_height * 4 + 96
dy += line_height if $imported["YEA-JPManager"]
fmt = YES::EQUIPMENT_LEARNING::VICTORY_AFTERMATH
text = sprintf(fmt, actor_elp_gain(actor).to_s, YES::EQUIPMENT_LEARNING::VOCAB)
contents.font.size = YEA::VICTORY_AFTERMATH::FONTSIZE_EXP
change_color(power_up_color)
draw_text(rect.x, dy, dw, line_height, text, 2)
end
#--------------------------------------------------------------------------
# actor_elp_gain
#--------------------------------------------------------------------------
def actor_elp_gain(actor)
n = $game_troop.elp_total
if actor.exp + actor_exp_gain(actor) > actor.exp_for_level(actor.level + 1)
n += YES::EQUIPMENT_LEARNING::LEVEL_UP unless actor.max_level?
end
return (n * actor.elr / 100).round
end
end # Window_VictoryEXP_Back
#==============================================================================
# ¡ Window_EquipLearning
#==============================================================================
class Window_EquipLearning < Window_Selectable
#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(x, y, width, height)
super(x, y, width, height)
self.opacity = 0
end
#--------------------------------------------------------------------------
# ap_gauge_color1
#--------------------------------------------------------------------------
def ap_gauge_color1
text_color(YES::EQUIPMENT_LEARNING::COLOR_GAUGE[:color1])
end
#--------------------------------------------------------------------------
# ap_gauge_color2
#--------------------------------------------------------------------------
def ap_gauge_color2
text_color(YES::EQUIPMENT_LEARNING::COLOR_GAUGE[:color2])
end
#--------------------------------------------------------------------------
# item_max
#--------------------------------------------------------------------------
def item_max
@data.nil? ? 1 : @data.size
end
#--------------------------------------------------------------------------
# current_item_enabled?
#--------------------------------------------------------------------------
def current_item_enabled?
false
end
#--------------------------------------------------------------------------
# enable?
#--------------------------------------------------------------------------
def enable?(skill)
true
end
#--------------------------------------------------------------------------
# equip=
#--------------------------------------------------------------------------
def equip=(equip)
contents.clear
@equip = equip
return unless @equip
@data = @equip.el_skills.collect { |i| $data_skills[i] }
refresh
end
#--------------------------------------------------------------------------
# actor=
#--------------------------------------------------------------------------
def actor=(actor)
@actor = actor
end
#--------------------------------------------------------------------------
# item
#--------------------------------------------------------------------------
def item
@data.nil? ? nil : @data[index]
end
#--------------------------------------------------------------------------
# draw_item
#--------------------------------------------------------------------------
def draw_item(index)
skill = @data[index]
if skill
rect = item_rect(index)
rect.width -= 4
draw_ap(skill, rect.x + 2, rect.y, rect.width, enable?(skill))
draw_item_name(skill, rect.x, rect.y, enable?(skill))
end
end
#--------------------------------------------------------------------------
# draw_ap
#--------------------------------------------------------------------------
def draw_ap(item, x, y, width, enable = true)
if @actor
draw_gauge(x, y, width - 4, @actor.per_elp(item.id),
ap_gauge_color1, ap_gauge_color2)
draw_current_and_max_values(x, y, width - 4, @actor.cur_elp(item.id),
@actor.req_elp(item.id), normal_color, normal_color)
else
draw_gauge(x, y, width - 4, 0,
ap_gauge_color1, ap_gauge_color2)
draw_current_and_max_values(x, y, width - 4, 0,
item.el_require, normal_color, normal_color)
end
end
#--------------------------------------------------------------------------
# update_help
#--------------------------------------------------------------------------
def update_help
@help_window.set_item(item)
end
#--------------------------------------------------------------------------
# activate
#--------------------------------------------------------------------------
def activate
self.index = 0
super
end
end # Window_EquipLearning
#==============================================================================
# ¡ Window_EquipLearning
#==============================================================================
class Window_EquipLearningBack < Window_Base
#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(x, y, width, height)
super(x, y, width, height)
refresh
end
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
contents.clear
text = YES::EQUIPMENT_LEARNING::LEARN_TITLE
change_color(system_color)
draw_text(0,0,contents.width,line_height,text,1)
end
end # Window_EquipLearningBack
#==============================================================================
# ¡ Window_EquipItem
#==============================================================================
class Window_EquipItem < Window_ItemList
if YES::EQUIPMENT_LEARNING::ENABLE_WINDOW
#--------------------------------------------------------------------------
# overwrite method: col_max
#--------------------------------------------------------------------------
def col_max
return 1
end
#--------------------------------------------------------------------------
# new method: equip_learning_window
#--------------------------------------------------------------------------
def equip_learning_window=(window)
@equip_learning_window = window
call_update_help
end
#--------------------------------------------------------------------------
# alias method: update_help
#--------------------------------------------------------------------------
alias yes_equip_learning_update_help update_help
def update_help
yes_equip_learning_update_help
@equip_learning_window.equip = self.item
end
end
end # Window_EquipItem
#==============================================================================
# ¡ Window_EquipSlot
#==============================================================================
class Window_EquipSlot < Window_Selectable
if YES::EQUIPMENT_LEARNING::ENABLE_WINDOW
#--------------------------------------------------------------------------
# new method: equip_learning_window
#--------------------------------------------------------------------------
def equip_learning_window=(window)
@equip_learning_window = window
call_update_help
end
#--------------------------------------------------------------------------
# alias method: update_help
#--------------------------------------------------------------------------
alias yes_equip_learning_update_help update_help
def update_help
yes_equip_learning_update_help
@equip_learning_window.equip = self.item
end
end
end # Window_EquipSlot
#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# new method: show_victory_el_learn
#--------------------------------------------------------------------------
def show_victory_el_learn(actor, temp_actor)
@victory_exp_window_back.hide
@victory_exp_window_front.hide
#---
fmt = YES::EQUIPMENT_LEARNING::VICTORY_LEARN
text = sprintf(fmt, actor.name)
@victory_title_window.refresh(text)
#---
@victory_level_window.show
@victory_level_window.refresh(actor, temp_actor)
@victory_level_skills.show
@victory_level_skills.refresh(actor, temp_actor)
end
end # Scene_Battle
#==============================================================================
# ¡ Scene_Equip
#==============================================================================
class Scene_Equip < Scene_MenuBase
if YES::EQUIPMENT_LEARNING::ENABLE_WINDOW
#--------------------------------------------------------------------------
# alias method: start
#--------------------------------------------------------------------------
alias yes_equip_learning_start start
def start
yes_equip_learning_start
create_equip_learning
end
#--------------------------------------------------------------------------
# alias method: create_item_window
#--------------------------------------------------------------------------
alias yes_equip_learning_create_item_window create_item_window
def create_item_window
yes_equip_learning_create_item_window
unless $imported["YEA-AceEquipEngine"]
@item_window.width = Graphics.width / 2
@item_window.create_contents
end
end
#--------------------------------------------------------------------------
# new method: create_equip_learning
#--------------------------------------------------------------------------
def create_equip_learning
wx = @item_window.width
wy = @item_window.y
ww = Graphics.width - @item_window.width
wh = @item_window.height
@equip_learning_back = Window_EquipLearningBack.new(wx, wy, ww, wh)
@equip_learning_back.viewport = @viewport
@equip_learning = Window_EquipLearning.new(wx, wy + 24, ww, wh - 24)
@equip_learning.viewport = @viewport
@equip_learning.help_window = @help_window
@equip_learning.actor = @actor
@item_window.equip_learning_window = @equip_learning
@slot_window.equip_learning_window = @equip_learning
#---
if $imported["YEA-AceEquipEngine"]
@equip_learning_back.hide
@equip_learning.hide
end
end
#--------------------------------------------------------------------------
# alias method: on_slot_cancel
#--------------------------------------------------------------------------
alias yes_equip_learning_on_slot_cancel on_slot_cancel
def on_slot_cancel
yes_equip_learning_on_slot_cancel
@equip_learning.equip = nil
end
#--------------------------------------------------------------------------
# alias method: on_actor_change
#--------------------------------------------------------------------------
alias yes_equip_learning_on_actor_change on_actor_change
def on_actor_change
yes_equip_learning_on_actor_change
@equip_learning.actor = @actor
@equip_learning.equip = nil
end
#--------------------------------------------------------------------------
# new method: command_learning
#--------------------------------------------------------------------------
def command_learning
if !@equip_learning.visible
@equip_learning.show
@equip_learning_back.show
@status_window.hide
else
@equip_learning.hide
@equip_learning_back.hide
@status_window.show
end
@command_window.activate
end
end
end # Scene_Equip
#==============================================================================
#
# ¥ End of File
#
#==============================================================================
You can’t perform that action at this time.