#===============================================================================
# Version 3.2.1.1
# Author: 332211 / uresk
# Date: 24th August 2009
#===============================================================================
#
# Autoskills can only activate if the battler could also use the skill
# by choice. By that, I mean that if you have another script that makes
# the skill require a certain type of weapon equiped, or a certain state,
# the skill will need to meet those requirements to activate.
#
# If you're using Yanfly Engine RD - Custom Skill Effects
# place the Attributes script below that script.
#
#===============================================================================
#
# To make an item which teaches attributes simply add to its notebox
# <teach attribute x>
# with x being the attribute index
#
# the tag <no class x> indicates a class which can't use the item
# with x being the class id
#
#===============================================================================
#
# The following tag
# <req attribute_name x>
# Can be applied to equipment (weapons and armors)
# Where x is the required attribute level
#
# A sword with <req Swordsmanship 3>
# can only be equiped when the hero's Swordsmanship is level 3 or above
# Notes:
# - if x is 0 (level 0) the hero still needs to have the attribute
# - other requirements (like class equipment) are still valid
#
# Can be applied to skills
# The skill, though it appears on the skills menu (when learnt)
# can only be used if the required attribute levels are met.
#
#===============================================================================
#
# An enemy with the tag
# <bonus points x>
# Will award x extra attribute points for each character.
#
#===============================================================================
#
# Enemies can have attributes too
# <attribute_name x>
#
# <Flame Mastery 3>
# means that the enemy will have the 'Flame Mastery' attribute at level 3
# Note: enemies' attributes only have the following effects:
# - damage modifiers
# - state probability alterations
#
#===============================================================================
# Start Configuration
#===============================================================================
module Attibute_Def
ATTRIBUTES = [

# ----------------#
# Attribute 0 #
# ----------------#
[
# "Name"
"Mestre das Chamas",
# --------------------------------------

{
# Bonus Values: -- { for no bonus, clear the lines} --
# level => [ HP, MP, ATK, DEF, SPI, AGI],
1 => [ 6, 8, 1, 0, 6, 1],
2 => [ 13, 18, 5, 0, 9, 7],
3 => [ 24, 32, 13, 0, 12, 15],
4 => [ 35, 45, 25, 0, 15, 21],
5 => [ 46, 58, 37, 0, 18, 28],
6 => [ 57, 71, 49, 0, 21, 33],
7 => [ 68, 84, 61, 0, 24, 39],
8 => [ 79, 97, 73, 0, 27, 45],
9 => [ 90, 110, 85, 0, 30, 51],
10 => [ 101, 150, 97, 0, 33, 57],
# --------------------------------------
},

{
# Damage/Defense Boost: -- { for no elements, clear the lines} --
# level => { element id => [attack multiplier, defense multiplier] },
1 => { 9 => [ 1.03, 0.98] },
2 => { 9 => [ 1.07, 0.95] },
3 => { 9 => [ 1.11, 0.93] },
4 => { 9 => [ 1.15, 0.90] },
5 => { 9 => [ 1.19, 0.88] },
6 => { 9 => [ 1.23, 0.85] },
7 => { 9 => [ 1.27, 0.83] },
8 => { 9 => [ 1.31, 0.80] },
9 => { 9 => [ 1.34, 0.78] },
10 => { 9 => [ 1.38, 0.75],
11 => [ 1.05, 0.98] },
# this line is also valid for level 4
# --------------------------------------
},

{
# Teaches skills: -- { for no skills, clear the lines} --
# attribute level => [skill id(s)]
1 => [2],
2 => [3],
3 => [4],
4 => [5],
5 => [6],
6 => [7],
7 => [8],
8 => [9],
10 => [10],
# --------------------------------------
},

{
# May activate skill: -- { for no skill, clear the lines} --
# *required element is optional*
# level => [ skill id, chance%],
1 => [ 11, 10],
2 => [ 11, 16],
3 => [ 11, 20],
4 => [ 11, 21],
5 => [ 11, 22],
6 => [ 11, 23],
7 => [ 11, 24],
8 => [ 11, 27],
9 => [ 11, 28],
10 => [ 11, 30],

# --------------------------------------
},

# Description:
# " text here "
"Mestre das Chamas: aprimora o espírito do usuário e seu dano por fogo
, pode ativar Chamas enquanto ataca.",
# --------------------------------------

{
# Sates alteration: -- { for no states, clear the lines} --
# level => { status id => probability diffence },
1 => { 17 => -10 },
2 => { 17 => -15 },
3 => { 17 => -20 },
4 => { 17 => -25 },
5 => { 17 => -30 },
6 => { 17 => -35 },
7 => { 17 => -40 },
8 => { 17 => -45 },
9 => { 17 => -50 },
10 => { 17 => -55,
13 => +11 },
# this line is also valid for level 4
# --------------------------------------
},

# Icon Index -- { for no icon, write 0 } --
104,
# --------------------------------------

# Max Level
10
# --------------------------------------
],

# ----------------#
# Attribute 1 #
# ----------------#
[
# "Name"
"Herói",
# --------------------------------------

{
# Bonus Values: -- { for no bonus, clear the lines} --
# level => [ HP, MP, ATK, DEF, SPI, AGI],
1 => [ 10 , 5 , 5 , 5 , 5 , 5 ],
2 => [ 30 , 10 , 10 , 10 , 10 , 10 ],
3 => [ 50 , 15 , 15 , 15 , 15 , 15 ],
4 => [ 70 , 20 , 20 , 20 , 20 , 20 ],
5 => [ 90 , 25 , 25 , 25 , 25 , 25 ],
6 => [ 110 , 30 , 30 , 30 , 30 , 30 ],
7 => [ 130 , 35 , 35 , 35 , 35 , 35 ],
8 => [ 150 , 40 , 40 , 40 , 40 , 40 ],
9 => [ 170 , 45 , 45 , 45 , 45 , 45 ],
10 => [ 190 , 50 , 50 , 50 , 50 , 50 ],
11 => [ 210 , 55 , 55 , 55 , 55 , 55 ],
12 => [ 230 , 60 , 60 , 60 , 60 , 60 ],
13 => [ 250 , 65 , 65 , 65 , 65 , 65 ],
14 => [ 270 , 70 , 70 , 70 , 70 , 70 ],
15 => [ 290 , 75 , 75 , 75 , 75 , 75 ],
16 => [ 310 , 80 , 80 , 80 , 80 , 80 ],
17 => [ 330 , 85 , 85 , 85 , 85 , 85 ],
18 => [ 350 , 90 , 90 , 90 , 90 , 90 ],
19 => [ 370 , 95 , 95 , 95 , 95 , 95 ],
20 => [ 390 , 100 , 100 , 100 , 100 , 100 ],
21 => [ 410 , 105 , 105 , 105 , 105 , 105 ],
22 => [ 430 , 110 , 110 , 110 , 110 , 110 ],
23 => [ 450 , 115 , 115 , 115 , 115 , 115 ],
24 => [ 470 , 120 , 120 , 120 , 120 , 120 ],
25 => [ 490 , 125 , 125 , 125 , 125 , 125 ],
26 => [ 510 , 130 , 130 , 130 , 130 , 130 ],
27 => [ 530 , 135 , 135 , 135 , 135 , 135 ],
28 => [ 550 , 140 , 140 , 140 , 140 , 140 ],
29 => [ 570 , 145 , 145 , 145 , 145 , 145 ],
30 => [ 590 , 150 , 150 , 150 , 150 , 150 ],
31 => [ 610 , 155 , 155 , 155 , 155 , 155 ],
32 => [ 630 , 160 , 160 , 160 , 160 , 160 ],
33 => [ 650 , 165 , 165 , 165 , 165 , 165 ],
34 => [ 670 , 170 , 170 , 170 , 170 , 170 ],
35 => [ 690 , 175 , 175 , 175 , 175 , 175 ],
36 => [ 710 , 180 , 180 , 180 , 180 , 180 ],
37 => [ 730 , 185 , 185 , 185 , 185 , 185 ],
38 => [ 750 , 190 , 190 , 190 , 190 , 190 ],
39 => [ 770 , 195 , 195 , 195 , 195 , 195 ],
40 => [ 790 , 200 , 200 , 200 , 200 , 200 ],
41 => [ 810 , 205 , 205 , 205 , 205 , 205 ],
42 => [ 830 , 210 , 210 , 210 , 210 , 210 ],
43 => [ 850 , 215 , 215 , 215 , 215 , 215 ],
44 => [ 870 , 220 , 220 , 220 , 220 , 220 ],
45 => [ 890 , 225 , 225 , 225 , 225 , 225 ],
46 => [ 910 , 230 , 230 , 230 , 230 , 230 ],
47 => [ 930 , 235 , 235 , 235 , 235 , 235 ],
48 => [ 950 , 240 , 240 , 240 , 240 , 240 ],
49 => [ 970 , 245 , 245 , 245 , 245 , 245 ],
50 => [ 990 , 250 , 250 , 250 , 250 , 250 ],


# --------------------------------------
},

{
# Damage/Defense Boost: -- { for no elements, clear the lines} --
# level => { element id => [attack multiplier, defense multiplier] },

# this line is also valid for level 4
# --------------------------------------
},

{
# Teaches skills: -- { for no skills, clear the lines} --
# attribute level => [skill id(s)]

# --------------------------------------
},

{
# May activate skill: -- { for no skill, clear the lines} --
# level => [ skill id, chance% ],
# --------------------------------------
},

# Description:
# " text here "
"Herói: Alguns indivíduos conseguem se sobrepor aos outros, a esses
chamamos de heróis.",
# --------------------------------------

{
# Sates alteration: -- { for no states, clear the lines} --
# level => { status id => probability diffence },
# --------------------------------------
},

# Icon Index -- { for no icon, write 0 } --
96,
# --------------------------------------

# Max Level
50
# --------------------------------------
],

# ----------------#
# Attribute 2 #
# ----------------#
[
# "Name"
"Arte das Trevas",
# --------------------------------------

{
# Bonus Values: -- { for no bonus, clear the lines} --
# level => [ HP, MP, ATK, DEF, SPI, AGI],
1 => [ 3, 6, 2, 2, 5, 4],
2 => [ 7, 15, 5, 3, 12, 8],
3 => [ 12, 25, 9, 5, 21, 14],
4 => [ 18, 37, 14, 7, 32, 21],
5 => [ 25, 51, 20, 11, 45, 31],
6 => [ 33, 67, 27, 13, 60, 40],
6 => [ 33, 67, 27, 13, 60, 40],
6 => [ 33, 67, 27, 13, 60, 40],
6 => [ 33, 67, 27, 13, 60, 40],
6 => [ 33, 67, 27, 13, 60, 40],
# --------------------------------------
},

{
# Damage/Defense Boost: -- { for no elements, clear the lines} --
# level => { element id => [attack multiplier, defense multiplier] },
1 => { 16 => [ 1.03, 0.98] },
2 => { 16 => [ 1.07, 0.95] },
3 => { 16 => [ 1.11, 0.93] },
4 => { 16 => [ 1.20, 0.85],
15 => [ 0.95, 1.05]},
5 => { 16 => [ 1.25, 0.80],
15 => [ 0.90, 1.11]},
6 => { 16 => [ 1.33, 0.50],
15 => [ 0.66, 1.50]},
7 => { 16 => [ 1.44, 0.40],
15 => [ 0.60, 1.60]},
8 => { 16 => [ 1.55, 0.35],
15 => [ 0.33, 1.80]},
9 => { 16 => [ 1.78, 0.30],
15 => [ 0.22, 1.90]},
10 => { 16 => [ 2.00, 0.25],
15 => [ 0.15, 2.00]},

# --------------------------------------
},

{
# Teaches skills: -- { for no skills, clear the lines} --
# attribute level => [skill id(s)]
1 => [13],
3 => [14],
5 => [15],
7 => [16],
8 => [17],
10 => [18],
# --------------------------------------
},

{
# May activate skill: -- { for no skill, clear the lines} --
# level => [ skill id, chance%],
1 => [ 19, 10 ],
2 => [ 19, 20 ],
3 => [ 19, 35 ],
4 => [ 19, 50 ],
5 => [ 19, 60 ],
6 => [ 19, 100 ],
# --------------------------------------
},

# Description:
# " text here "
"Artes das Trevas: A Magia Negra consiste em enfraquecer seus inimigos.
Quanto mais se avança nesta arte, O usuário se torna mais vulnerável a
danos por Luz emais resistente a danos por Trevas.",
# --------------------------------------

{
# Sates alteration: -- { for no states, clear the lines} --
# level => { status id => probability diffence },
1 => { 3 => -10 },
2 => { 3 => -20 },
3 => { 3 => -30 },
4 => { 3 => -40 },
5 => { 3 => -50 },
6 => { 3 => -60 },
# --------------------------------------
},

# Icon Index -- { for no icon, write 0 } --
111,
# --------------------------------------

# Max Level
10
# --------------------------------------
],
# ----------------#
# Attribute 3 #
# ----------------#
[
# "Name"
"A Força do Trovão",
# --------------------------------------

{
# Bonus Values: -- { for no bonus, clear the lines} --
# level => [ HP, MP, ATK, DEF, SPI, AGI],
1 => [ 3, 6, 2, 2, 5, 4],
2 => [ 7, 15, 5, 3, 12, 8],
3 => [ 12, 25, 9, 5, 21, 14],
4 => [ 18, 37, 14, 7, 32, 21],
5 => [ 25, 51, 20, 11, 45, 31],
6 => [ 33, 67, 27, 13, 60, 40],
7 => [ 40, 80, 35, 15, 75, 50],
8 => [ 50, 90, 44, 17, 90, 60],
9 => [ 60, 100, 54, 19, 105, 70],
10 => [ 70, 110, 65, 21, 130, 80],
# --------------------------------------
},

{
# Damage/Defense Boost: -- { for no elements, clear the lines} --
# level => { element id => [attack multiplier, defense multiplier] },
1 => { 11 => [ 1.03, 0.98] },
2 => { 11 => [ 1.06, 0.95] },
3 => { 11 => [ 1.09, 0.91] },
4 => { 11 => [ 1.12, 0.85] },
5 => { 11 => [ 1.16, 0.78] },
6 => { 11 => [ 1.24, 0.70] },
7 => { 11 => [ 1.28, 0.65] },
8 => { 11 => [ 1.32, 0.60] },
9 => { 11 => [ 1.36, 0.55] },
10 => { 11 => [ 1.40, 0.50] },
# --------------------------------------
},

{
# Teaches skills: -- { for no skills, clear the lines} --
# attribute level => [skill id(s)]
1 => [21],
3 => [22],
4 => [23],
5 => [24],
6 => [25],
7 => [26],
8 => [27],
9 => [28],
10 => [29],
# --------------------------------------
},

{
# May activate skill: -- { for no skill, clear the lines} --
# level => [ skill id, chance% ],
1 => [ 21, 7 ],
2 => [ 21, 13 ],
3 => [ 21, 18 ],
4 => [ 21, 22 ],
5 => [ 21, 25 ],
6 => [ 21, 27 ],
7 => [ 21, 28 ],
8 => [ 21, 29 ],
9 => [ 21, 30 ],
10 => [ 21, 35 ],
# --------------------------------------
},

# Description:
# " text here "
"A força do Trovão: É a habilidade de manipular a eletricidade.
Usuários avançados conseguem paralizar os adversários.",
# --------------------------------------

{
# Sates alteration: -- { for no states, clear the lines} --
# level => { status id => probability diffence },
1 => { 7 => -10 },
2 => { 7 => -15,
8 => -10 },
3 => { 7 => -18,
8 => -13 },
4 => { 7 => -23,
8 => -18 },
5 => { 7 => -30,
8 => -25 },
6 => { 7 => -35,
8 => -35 },
# --------------------------------------
},

# Icon Index -- { for no icon, write 0 } --
106,
# --------------------------------------

# Max Level
10
# --------------------------------------
],
# ----------------#
# Attribute 4 #
# ----------------#
[
# "Name"
"Manuseio da Espada",
# --------------------------------------

{
# Bonus Values: -- { for no bonus, clear the lines} --
# level => [ HP, MP, ATK, DEF, SPI, AGI],
1 => [ 5 , 0 , 5 , 1 , 0 , 1 ],
2 => [ 10 , 0 , 7 , 2 , 0 , 2 ],
3 => [ 15 , 0 , 9 , 3 , 0 , 3 ],
4 => [ 20 , 0 , 11 , 4 , 0 , 4 ],
5 => [ 25 , 0 , 13 , 5 , 0 , 5 ],
6 => [ 30 , 0 , 15 , 6 , 0 , 6 ],
7 => [ 35 , 0 , 17 , 7 , 0 , 7 ],
8 => [ 40 , 0 , 19 , 8 , 0 , 8 ],
9 => [ 45 , 0 , 21 , 9 , 0 , 9 ],
10 => [ 50 , 0 , 23 , 10 , 0 , 10 ],
11 => [ 55 , 0 , 25 , 11 , 0 , 11 ],
12 => [ 60 , 0 , 27 , 12 , 0 , 12 ],
13 => [ 65 , 0 , 29 , 13 , 0 , 13 ],
14 => [ 70 , 0 , 31 , 14 , 0 , 14 ],
15 => [ 75 , 0 , 33 , 15 , 0 , 15 ],
16 => [ 80 , 0 , 35 , 16 , 0 , 16 ],
17 => [ 85 , 0 , 37 , 17 , 0 , 17 ],
18 => [ 90 , 0 , 39 , 18 , 0 , 18 ],
19 => [ 95 , 0 , 41 , 19 , 0 , 19 ],
20 => [ 100 , 0 , 43 , 20 , 0 , 20 ],

# --------------------------------------
},

{
# Damage/Defense Boost: -- { for no elements, clear the lines} --
# level => { element id => [attack multiplier, defense multiplier] },
1 => { 2 => [ 1.03, 0.98] },
2 => { 2 => [ 1.07, 0.95] },
3 => { 2 => [ 1.11, 0.93] },
4 => { 2 => [ 1.15, 0.90] },
5 => { 2 => [ 1.19, 0.88] },
6 => { 2 => [ 1.23, 0.85] },
7 => { 2 => [ 1.27, 0.83] },
8 => { 2 => [ 1.31, 0.80] },
9 => { 2 => [ 1.34, 0.78] },
10 => { 2 => [ 1.38, 0.75] },
11 => { 2 => [ 1.42, 0.73] },
12 => { 2 => [ 1.46, 0.70] },
13 => { 2 => [ 1.50, 0.68] },
14 => { 2 => [ 1.54, 0.65] },
15 => { 2 => [ 1.58, 0.63] },
16 => { 2 => [ 1.62, 0.60] },
17 => { 2 => [ 1.66, 0.58] },
18 => { 2 => [ 1.70, 0.55] },
19 => { 2 => [ 1.74, 0.53] },
20 => { 2 => [ 1.78, 0.50] },

# this line is also valid for level 4
# --------------------------------------
},

{
# Teaches skills: -- { for no skills, clear the lines} --
# attribute level => [skill id(s)]
1 => [31],
3 => [32],
6 => [33],
9 => [34],
12 => [35],
15 => [36],

# --------------------------------------
},

{
# May activate skill: -- { for no skill, clear the lines} --
# *required element is optional*
# level => [ skill id, chance%],


# --------------------------------------
},

# Description:
# " text here "
"Manejo da Espada: Aprimora as habilidades de combate com a espada.
Usuários avançados podem desferir grandes quantidades de dano.",
# --------------------------------------

{
# Sates alteration: -- { for no states, clear the lines} --
# level => { status id => probability diffence },

# this line is also valid for level 4
# --------------------------------------
},

# Icon Index -- { for no icon, write 0 } --
9,
# --------------------------------------

# Max Level
20
# --------------------------------------
],
# ----------------#
# Attribute 5 #
# ----------------#
[
# "Name"
"Retalhador",
# --------------------------------------

{
# Bonus Values: -- { for no bonus, clear the lines} --
# level => [ HP, MP, ATK, DEF, SPI, AGI],
1 => [ 0 , 0 , 5 , 0 , 0 , 5 ],
2 => [ 0 , 0 , 15 , 0 , 0 , 15 ],
3 => [ 0 , 0 , 40 , 0 , 0 , 40 ],
4 => [ 0 , 0 , 90 , 0 , 0 , 90 ],
5 => [ 0 , 0 , 110 , 0 , 0 , 110 ],


# --------------------------------------
},

{
# Damage/Defense Boost: -- { for no elements, clear the lines} --
# level => { element id => [attack multiplier, defense multiplier] },
1 => { 2 => [ 1.50, 0.98],
19 => [ 1.50, 0.98],
19 => [ 1.50, 0.98]},
2 => { 2 => [ 2.00, 0.98],
19 => [ 2.00, 0.98],
19 => [ 2.00, 0.98]},
3 => { 2 => [ 3.00, 0.98],
19 => [ 3.00, 0.98],
19 => [ 3.00, 0.98]},
4 => { 2 => [ 4.00, 0.98],
19 => [ 4.00, 0.98],
19 => [ 4.00, 0.98]},
5 => { 2 => [ 5.00, 0.98],
19 => [ 5.00, 0.98],
19 => [ 5.00, 0.98]},
# this line is also valid for level 4
# --------------------------------------
},

{
# Teaches skills: -- { for no skills, clear the lines} --
# attribute level => [skill id(s)]


# --------------------------------------
},

{
# May activate skill: -- { for no skill, clear the lines} --
# *required element is optional*
# level => [ skill id, chance%],


# --------------------------------------
},

# Description:
# " text here "
"Retalhador: O Retalhador consegue usar melhor as Lãminas aplicando
um dano muito maior.",
# --------------------------------------

{
# Sates alteration: -- { for no states, clear the lines} --
# level => { status id => probability diffence },

# this line is also valid for level 4
# --------------------------------------
},

# Icon Index -- { for no icon, write 0 } --
9,
# --------------------------------------

# Max Level
20
# --------------------------------------
],
]
# Innate attributes

# Actor based
Actor_attributes =
{
# Actor Id 1
1 => {
#~ 2 => [0]
},
# Actor Id 3
3 => {
}
}

# Class based
Class_attributes =
{
# Class Id 1
1 => {
},

# Class Id 2
1 => {
# level => [attribute ids...]
#~ 1 => [0],
},

}

# Upgrade Cost Formula
def cost?(level)
level += 3
cost = (level * level + level)/2
return cost
end

# By setting numbers are be chosing which item(s) can be sold
# as attribute points
Items_points_id = [22,23]

# Allow for an information window to appear if A (default: shift)
# is pressed?
Info_window = true


# Hide the following status from that window
HIDE_S = []

# Associate each element with an icon
# * Elements not indicated here will not appear in thi window
ELEMENT_ICONS = { 1 => 132,
2 => 10,
3 => 4,
4 => 14,
5 => 16,
6 => 12,
9 => 104,
10 => 105,
11 => 106,
12 => 107,
13 => 108,
14 => 109,
15 => 110,
16 => 111,
} # Do not remove this.

end

# Message shown when you buy attribute points
Vocab::Shop_text = "%s comprou %s pontos de atributos."
# %s - actor
# %s - number of points

# Message shown when you earn extra attribute points
Vocab::Bonus_Points = "O grupo ganhou %s pontos de atributos"
# %s - number of points
# note: 's' will be added to the message if more than 1 point is gained.


imported = {} if imported.nil?
imported["Attributes"] = true
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
include Attibute_Def
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :attributes # attributes
attr_accessor :attr_points # points
#--------------------------------------------------------------------------
# * Setup
# actor_id : actor ID
#--------------------------------------------------------------------------
alias attributes_setup setup
def setup(actor_id)
attributes_setup(actor_id)
@attributes = {}
@attr_points = 0
l = @level
for a in 1..l
@attr_points += a
update_attributes
end
end

#--------------------------------------------------------------------------
# * Attributes
# id : attribute ID
#--------------------------------------------------------------------------
def start_attribute(id)
index = @attributes.index(Attribute.new(id))
@attributes[id] = Attribute.new(id) if index.nil?
end

def remove_attribute(id)
reset_attribute(id)
@attributes.delete(id)
end

def reset_attribute(id)
while @attributes[d].level > 0
attribute_down(id)
end
end

def attribute_up(id)
return if @attributes[id].level == @attributes[id].max_level
#----------------------------------------
@maxhp_plus -= @attributes[id].bonus[0]
@maxmp_plus -= @attributes[id].bonus[1]
@atk_plus -= @attributes[id].bonus[2]
@def_plus -= @attributes[id].bonus[3]
@spi_plus -= @attributes[id].bonus[4]
@agi_plus -= @attributes[id].bonus[5]
#----------------------------------------
@attributes[id].upgrade
#----------------------------------------
@maxhp_plus += @attributes[id].bonus[0]
@maxmp_plus += @attributes[id].bonus[1]
@atk_plus += @attributes[id].bonus[2]
@def_plus += @attributes[id].bonus[3]
@spi_plus += @attributes[id].bonus[4]
@agi_plus += @attributes[id].bonus[5]
#----------------------------------------
for skill in @attributes[id].skills
learn_skill(skill)
end
end

def attribute_down(id)
return if @attributes[id].level == 0
#----------------------------------------
@maxhp_plus -= @attributes[id].bonus[0]
@maxmp_plus -= @attributes[id].bonus[1]
@atk_plus -= @attributes[id].bonus[2]
@def_plus -= @attributes[id].bonus[3]
@spi_plus -= @attributes[id].bonus[4]
@agi_plus -= @attributes[id].bonus[5]
#----------------------------------------
for skill in @attributes[id].skills
forget_skill(skill)
end
@attributes[id].downgrade
#----------------------------------------
@maxhp_plus += @attributes[id].bonus[0]
@maxmp_plus += @attributes[id].bonus[1]
@atk_plus += @attributes[id].bonus[2]
@def_plus += @attributes[id].bonus[3]
@spi_plus += @attributes[id].bonus[4]
@agi_plus += @attributes[id].bonus[5]
#----------------------------------------
end

#--------------------------------------------------------------------------
# * Level Up
#--------------------------------------------------------------------------
alias attr_level_up level_up
def level_up
attr_level_up
@attr_points += @level
update_attributes
end
#--------------------------------------------------------------------------
# * Level Down
#--------------------------------------------------------------------------
alias attr_level_down level_down
def level_down
attr_level_down
update_attributes
@attr_points -= @level
end

#--------------------------------------------------------------------------
# * Upgrade Attribute
#--------------------------------------------------------------------------
def upgrade_attr(id)
@attr_points -= cost?(@attributes[id].level)
attribute_up(id)
end

def update_attributes
a = @level
if !Actor_attributes[@actor_id].nil?
if !Actor_attributes[@actor_id][a].nil?
for attr_i in Actor_attributes[@actor_id][a]
start_attribute(attr_i) unless @attributes.has_key?(attr_i)
end
end
end
if !Class_attributes[class_id].nil?
if !Class_attributes[class_id][a].nil?
for attr_i in Class_attributes[class_id][a]
start_attribute(attr_i) unless @attributes.has_key?(attr_i)
end
end
end
end

#--------------------------------------------------------------------------
# * Get Added State Success Rate
# state_id : state ID
#--------------------------------------------------------------------------
alias attr_state_probability state_probability
def state_probability(state_id)
n = attr_state_probability(state_id)
for id in @attributes.keys
if @attributes[id].states.include?(state_id)
n += @attributes[id].states[state_id]
end
end
return n
end

#--------------------------------------------------------------------------
# * Change Class ID
# class_id : New class ID
#--------------------------------------------------------------------------
alias attr_class_id class_id=
def class_id=(class_id)
attr_class_id(class_id)
update_attributes
end

#--------------------------------------------------------------------------
# * Determine if Equippable
# item : item
#--------------------------------------------------------------------------
alias attr_equippable? equippable?
def equippable?(item)
item.req_attribute.each {|attr_id, a_level|
if @attributes[attr_id].nil?
return false
break
end
return false unless @attributes[attr_id].level >= a_level }
attr_equippable?(item)
end

#--------------------------------------------------------------------------
# * Determine Usable Skills
# skill : skill
#--------------------------------------------------------------------------
alias attr_skill_can_use? skill_can_use?
def skill_can_use?(skill)
skill.req_attribute.each {|attr_id, a_level|
if @attributes[attr_id].nil?
return false
break
end
return false unless @attributes[attr_id].level >= a_level }
attr_skill_can_use?(skill)
end

end

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# This class deals with battlers. It's used as a superclass of the Game_Actor
# and Game_Enemy classes.
#==============================================================================

class Game_Battler
include Attibute_Def
#--------------------------------------------------------------------------
# * Calculation of Damage Caused by Skills or Items
# user : User of skill or item
# obj : Skill or item (for normal attacks, this is nil)
# The results are substituted for @hp_damage or @mp_damage.
#--------------------------------------------------------------------------
alias attr_make_obj_damage_value make_obj_damage_value
def make_obj_damage_value(user, obj)
mult = 1
if !user.attributes.nil?
for id in user.attributes.keys
for element in user.attributes[id].elements.keys & obj.element_set
mult += user.attributes[id].elements[element][0] - 1
end
end
end
div = 1
if !self.attributes.nil?
for id in self.attributes.keys
for element in self.attributes[id].elements.keys & obj.element_set
div *= self.attributes[id].elements[element][1]
end
end
end
new = obj.clone
new.base_damage = (obj.base_damage * mult * div).round
attr_make_obj_damage_value(user, new)
end
end

#==============================================================================
# ** Game_BattleAction
#------------------------------------------------------------------------------
# This class handles battle actions. This class is used within the
# Game_Battler class.
#==============================================================================

class Game_BattleAction
include Attibute_Def
#--------------------------------------------------------------------------
# * Set Normal Attack
#--------------------------------------------------------------------------
alias attr_set_attack set_attack
def set_attack
activated_special_skill = false
if !@battler.attributes.nil?
auto_skills = []
for id in @battler.attributes.keys
if rand(100) < @battler.attributes[id].auto_skill_chance
s_id = @battler.attributes[id].auto_skill
if @battler.skill_learn?($data_skills[s_id])
if @battler.skill_can_use?($data_skills[s_id])
auto_skills.push(s_id)
activated_special_skill = true
end
else
@battler.learn_skill(s_id)
if @battler.skill_can_use?($data_skills[s_id])
auto_skills.push(s_id)
activated_special_skill = true
end
@battler.forget_skill(s_id)
end
end
end
end
if activated_special_skill
skill = auto_skills[rand(auto_skills.size)]
set_skill(skill)
@battler.action.forcing = true
else
attr_set_attack
end
end
end

class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * End Target Enemy Selection
#--------------------------------------------------------------------------
alias attr_end_target_enemy_selection end_target_enemy_selection
def end_target_enemy_selection
attr_end_target_enemy_selection
if @active_battler.action.forcing and @active_battler.is_a?(Game_Actor) and @active_battler.action.skill?
for attr in @active_battler.attributes.keys
if @active_battler.action.skill.id == @active_battler.attributes[attr].auto_skill
unless [1,2,3,4,5,6].include?(@active_battler.action.skill.scope)
@active_battler.action.decide_random_target
end
end
end
end
end
end

module RPG

class Enemy
def bonus_points
bonus_points = 0
self.note.split(/[\r\n]+/).each { |line|
case line
when /<BONUS_POINTS|bonus points\s*(\d+)>/i
bonus_points = $1.to_i
end
}
return [0, bonus_points].max
end

def attributes
create_attributes if @attributes.nil?
return @attributes
end

def create_attributes
@attributes = {}
for id in 0...Attibute_Def::ATTRIBUTES.size
attribute = Attribute.new(id)
compare = /<#{Regexp.quote(attribute.name)}\s*(\d+)>/i
self.note.split(/[\r\n]+/).each { |line|
case line
when compare
level = $1.to_i
@attributes[id] = attribute
while @attributes[id].level < level
@attributes[id].upgrade
break if @attributes[id].maxed?
end
end
}
end
end
end # End: class Enemy

class Item < UsableItem
def start_attr_cache
@teach_attributes = []; @non_usable = []
self.note.split(/[\r\n]+/).each { |line|
case line
when /<TEACH_ATTRIBUTE|teach attribute\s*(\d+)>/i
@teach_attributes.push($1.to_i)
when /<NO_CLASS|no class\s*(\d+)>/i
@non_usable.push($1.to_i)
end
}
end
attr_reader :teach_attributes
attr_reader :non_usable
end # End: class Item < UsableItem

class Weapon < BaseItem
def req_attribute
req_attr = {}
for id in 0...Attibute_Def::ATTRIBUTES.size
attribute = Attribute.new(id)
compare = /<req #{Regexp.quote(attribute.name)}\s*(\d+)>/i
self.note.split(/[\r\n]+/).each { |line|
line
case line
when compare
req_attr[id] = $1.to_i
end
}
end
return req_attr
end
end # End: class Weapon < BaseItem

class Armor < BaseItem
def req_attribute
req_attr = {}
for id in 0...Attibute_Def::ATTRIBUTES.size
attribute = Attribute.new(id)
compare = /<req #{Regexp.quote(attribute.name)}\s*(\d+)>/i
self.note.split(/[\r\n]+/).each { |line|
case line
when compare
req_attr[id] = $1.to_i
end
}
end
return req_attr
end
end # End: class Armor < BaseItem

class UsableItem < BaseItem
def req_attribute
req_attr = {}
for id in 0...Attibute_Def::ATTRIBUTES.size
attribute = Attribute.new(id)
compare = /<req #{Regexp.quote(attribute.name)}\s*(\d+)>/i
self.note.split(/[\r\n]+/).each { |line|
case line
when compare
req_attr[id] = $1.to_i
end
}
end
return req_attr
end
end # End: class UsableItem < BaseItem

end # End: module RPG


#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================

class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :attributes
#--------------------------------------------------------------------------
# * Object Initialization
# index : index in troop
# enemy_id : enemy ID
#--------------------------------------------------------------------------
alias attr_initialize initialize
def initialize(index, enemy_id)
attr_initialize(index, enemy_id)
@attributes = enemy.attributes
end

#--------------------------------------------------------------------------
# * Get Added State Success Rate
# state_id : state ID
#--------------------------------------------------------------------------
alias attr_state_probability state_probability
def state_probability(state_id)
n = attr_state_probability(state_id)
for id in @attributes.keys
if @attributes[id].states.include?(state_id)
n += @attributes[id].states[state_id]
end
end
return n
end

end # End: class Game_Enemy < Game_Battler


#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# This class deals with battlers. It's used as a superclass of the Game_Actor
# and Game_Enemy classes.
#==============================================================================

class Game_Battler
alias attr_item_effective? item_effective?
#--------------------------------------------------------------------------
# * Determine if an Item can be Used
# user : Item user
# item : item
#--------------------------------------------------------------------------
def item_effective?(user, item)
item.start_attr_cache
return false if item.non_usable.include?(user.class.id)
for t in item.teach_attributes
return true if !user.attributes.include?(t)
end
attr_item_effective?(user, item)
end

alias attr_item_effect item_effect
#--------------------------------------------------------------------------
# * Apply Item Effects
# user : Item user
# item : item
#--------------------------------------------------------------------------
def item_effect(user, item)
attr_item_effect(user, item)
item.start_attr_cache
for t in item.teach_attributes
user.start_attribute(t) if !user.attributes.include?(t) and !@skipped
end
end
end

#==============================================================================
# ** Scene_Shop
#------------------------------------------------------------------------------
# This class performs shop screen processing.
#==============================================================================

class Scene_Shop < Scene_Base
#--------------------------------------------------------------------------
# * Start processing
#--------------------------------------------------------------------------
alias attr_points_start start
def start
attr_points_start
@select_actor = Window_Select_Actor.new(0, 112)
@select_actor.active = false
@select_actor.visible = false
end
#--------------------------------------------------------------------------
# * Termination Processing
#--------------------------------------------------------------------------
alias attr_points_terminate terminate
def terminate
attr_points_terminate
@select_actor.dispose
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
alias attr_points_update update
def update
@select_actor.update
if @select_actor.active
update_actor_selection
else
attr_points_update
end
end
#--------------------------------------------------------------------------
# * Confirm Number Input
#--------------------------------------------------------------------------
alias attr_points_decide_number_input decide_number_input
def decide_number_input
if Attibute_Def::Items_points_id.include?(@buy_window.item.id)
Sound.play_decision
@buy_window.active = false
@buy_window.visible = false
@number_window.active = false
@number_window.visible = false
@select_actor.active = true
@select_actor.visible = true
@select_actor.refresh
@status_window.active = false
@status_window.visible = false
else
attr_points_decide_number_input
end
end
#--------------------------------------------------------------------------
# * Update Actor Selection
#--------------------------------------------------------------------------
def update_actor_selection
if Input.trigger?(Input::
Sound.play_cancel
@number_window.active = true
@number_window.visible = true
@number_window.refresh
@select_actor.active = false
@select_actor.visible = false
@status_window.active = true
@status_window.visible = true
@status_window.refresh
elsif Input.trigger?(Input::C)
actor = $game_party.members[@select_actor.index]
actor.attr_points += @number_window.number
$game_party.lose_gold(@number_window.number * @item.price)
text = sprintf(Vocab::Shop_text, actor.name, @number_window.number)
@help_window.set_text(text)
Sound.play_shop
for i in 0..30
Graphics.update
end
@gold_window.refresh
@buy_window.active = true
@buy_window.visible = true
@buy_window.refresh
@select_actor.active = false
@select_actor.visible = false
@status_window.active = true
@status_window.visible = true
@status_window.refresh
end
end
end

#==============================================================================
# ** Window_Select_Actor
#------------------------------------------------------------------------------
# Shop actor selection window.
#==============================================================================
class Window_Select_Actor < Window_Selectable
#--------------------------------------------------------------------------
# * Initialize
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 544, 97 + WLH * 4)
refresh
self.index = 0
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
x = 10; y = 92
@item_max = 0
for actor in $game_party.members
draw_actor_face(actor, x, 0, y)
draw_actor_name(actor, x, y)
draw_actor_class(actor, x, y + (WLH-2) * 2)
draw_actor_level(actor, x, y + WLH - 2)
x += 544/4
@item_max += 1
end
@column_max = @item_max
end
#--------------------------------------------------------------------------
# * Update cursor
#--------------------------------------------------------------------------
def update_cursor
self.cursor_rect.set(@index * 544/4, 0, 544/4 - 24, contents.height)
end
end

#==============================================================================
# ** Window_Attr_Desc
#------------------------------------------------------------------------------
# This window shows attribute explanations.
#==============================================================================

class Window_Attr_Desc < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 0, 544, 3 * WLH + 32)
end
#--------------------------------------------------------------------------
# * Set Text
# text : character string displayed in window
# align : alignment (0..flush left, 1..center, 2..flush right)
#--------------------------------------------------------------------------
def set_text(text, align = 0)
if text != @text or align != @align
self.contents.clear
self.contents.font.color = normal_color
self.contents.draw_wrap_text(4, -4, self.width - 40, WLH, text, align)
@text = text
@align = align
end
end
end

class Bitmap
def draw_wrap_text(x,y,width, height, text, align)
array = text.split
for i in array
word = i + ' '
word_width = text_size(word).width
if x + word_width > width
y += (height + 10) / 2
x = 0
end
self.draw_text(x, y, width, height, word)
x += (word_width + 0)
end
end
end

#==============================================================================
# ** Window_Atrr_List
#------------------------------------------------------------------------------
# This window displays a list of attributes
#==============================================================================

class Window_Atrr_List < Window_Selectable
include Attibute_Def
#--------------------------------------------------------------------------
# * Object Initialization
# x : window x-coordinate
# y : window y-coordinate
# width : window width
# height : window height
# actor : actor
#--------------------------------------------------------------------------
def initialize(x, y, width, height, actor)
super(x, y, width, height)
@actor = actor
@column_max = 1
self.index = 0
refresh
end
#--------------------------------------------------------------------------
# * Get Attribute
#--------------------------------------------------------------------------
def on_attribute
return @actor.attributes[@actor.attributes.keys[self.index]]
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
@item_max = @actor.attributes.keys.size
create_contents
for a in 0...@item_max
draw_attribute(a)
end
end
#--------------------------------------------------------------------------
# * Draw Attribute
#--------------------------------------------------------------------------
def draw_attribute(a)
self.contents.clear_rect(item_rect(a))
attr = @actor.attributes[@actor.attributes.keys[a]]
self.contents.draw_text(item_rect(a), attr.name)
for level in 0...attr.level
draw_icon(attr.icon,150 + level * 30, item_rect(a).y)
end
end
#--------------------------------------------------------------------------
# * Update Attr Window text
#--------------------------------------------------------------------------
def update_help
if on_attribute.nil?
text = ""
else
text = on_attribute.description
end
@help_window.set_text(text)
end
end

#==============================================================================
# ** Window_Points_Status
#------------------------------------------------------------------------------
# This window displays the user's Points, Attribute level, and Cost to Upgrade
# on the attrbitutes screen.
#==============================================================================

class Window_Point_Status < Window_Base
include Attibute_Def
#--------------------------------------------------------------------------
# * Object Initialization
# x : window X coordinate
# y : window Y corrdinate
# actor : actor
#--------------------------------------------------------------------------
def initialize(x, y, actor)
super(x, y, 240, WLH*3 + 32)
@actor = actor
refresh
end

def points
points = @actor.attr_points
end

def level
if $scene.on_attribute.nil?
level = 0
else
level = $scene.on_attribute.level
end
end

def upgrade
upgrade = cost?(level)
end

#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.draw_text(0, (WLH - 26), 172, WLH, "Points: ")
self.contents.draw_text(70, (WLH - 26), 172, WLH, points)
self.contents.draw_text(0, WLH - 2 , 172, WLH, "Level: ")
self.contents.draw_text(70, WLH - 2, 172, WLH, level)
self.contents.draw_text(0, WLH + 24, 172, WLH, "Cost to Upgrade: ")
unless $scene.on_attribute.nil?
up = upgrade; up= "-" if level == $scene.on_attribute.max_level
self.contents.draw_text(160, WLH + 24, 172, WLH, up)
end
end
end

#==============================================================================
# ** Window_Attr_Status
#------------------------------------------------------------------------------
# This window displays the user's status on the attrbitutes screen.
#==============================================================================

class Window_Attr_Status < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
# x : window X coordinate
# y : window Y corrdinate
# actor : actor
#--------------------------------------------------------------------------
def initialize(x, y, actor)
super(x, y, 304, WLH*3 + 32)
@actor = actor
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
contents.font.size = 16
self.contents.font.color = system_color
self.contents.draw_text(0, WLH, 172, WLH, "ATK:")
self.contents.draw_text(0, (WLH + 10) , 172, WLH, "DEF:")
self.contents.draw_text(0, (WLH + 20), 172, WLH, "SPI:")
self.contents.draw_text(0, (WLH + 30), 172, WLH, "AGI:")
self.contents.font.color = normal_color
self.contents.draw_text(40, WLH, 172, WLH, @actor.atk)
self.contents.draw_text(40, (WLH + 10), 172, WLH, @actor.def)
self.contents.draw_text(40, (WLH + 20), 172, WLH, @actor.spi)
self.contents.draw_text(40, (WLH + 30), 172, WLH, @actor.agi)

draw_actor_name(@actor, 4, 0)
draw_actor_level(@actor, 100, 0)
draw_actor_graphic(@actor, 110, 70)
draw_actor_hp(@actor, 140, 20)
draw_actor_mp(@actor, 140, 40)
end
end

#==============================================================================
# ** Scene_Attributes
#------------------------------------------------------------------------------
# This class performs the skill screen processing.
#==============================================================================

class Scene_Attributes < Scene_Base
include Attibute_Def
#--------------------------------------------------------------------------
# * Object Initialization
# actor_index : actor index
#--------------------------------------------------------------------------
def initialize(actor_index = 0)
@actor_index = actor_index
end
#--------------------------------------------------------------------------
# * Start processing
#--------------------------------------------------------------------------
def start
super
create_menu_background
@actor = $game_party.members[@actor_index]
@viewport = Viewport.new(0, 416-104, 544, 416)
@help_window = Window_Attr_Desc.new
@help_window.viewport = @viewport
@attr_window = Window_Atrr_List.new(0, 104, 544, 304-96, @actor)
@attr_window.help_window = @help_window
@attr_window.active = true
@status_window = Window_Attr_Status.new(0, 0, @actor)
@status2_window = Window_Point_Status.new(304, 0, @actor)
@info_window = Attr_Info_window.new(@actor)
@info_window.hide
@confirm_window = Window_Attribute_Confirm.new
@confirm_window.hide
end
#--------------------------------------------------------------------------
# * Get current Attribute
#--------------------------------------------------------------------------
def on_attribute
@attr_window.on_attribute
end
#--------------------------------------------------------------------------
# * Termination Processing
#--------------------------------------------------------------------------
def terminate
super
dispose_menu_background
@help_window.dispose
@attr_window.dispose
@status_window.dispose
@status2_window.dispose
@info_window.dispose
@confirm_window.dispose
end
#--------------------------------------------------------------------------
# * Return to Original Screen
#--------------------------------------------------------------------------
def return_scene
if $imported["SceneStatusReDux"] and YE::REDUX::STATUS::STATUS_COMMANDS.include?(301)
commands = []
index_list = {}
YE::REDUX::STATUS::STATUS_COMMANDS.each_with_index { |c, i|
case c
when 0 # View Statistics
index_list[:stats] = commands.size
commands.push(YE::REDUX::STATUS::STATUS)

when 1 # View Biography
index_list[:bio] = commands.size
commands.push(YE::REDUX::STATUS::BIO)

when 2 # Skill Menu
index_list[:skill] = commands.size
commands.push(Vocab.skill)

when 3 # Equipment
index_list[:equip] = commands.size
commands.push(Vocab.equip)

when 4 # Change Class
next unless $imported["SubclassSelectionSystem"]
next unless $game_switches[YE::SUBCLASS::ENABLE_CLASS_CHANGE_SWITCH]
index_list[:classchange] = commands.size
commands.push(YE::SUBCLASS::MENU_CLASS_CHANGE_TITLE)

when 5 # Learn Skill
next unless $imported["SubclassSelectionSystem"]
next unless $game_switches[YE::SUBCLASS::ENABLE_LEARN_SKILLS_SWITCH]
index_list[:learnskill] = commands.size
commands.push(YE::SUBCLASS::LEARN_SKILL_TITLE)

when 6 # Skill Slots
next unless $imported["EquipSkillSlots"]
next unless $game_switches[YE::EQUIPSKILL::ENABLE_SLOTS_SWITCH]
index_list[:equipskill] = commands.size
commands.push(YE::EQUIPSKILL::MENU_TITLE)

when 301
$scene = Scene_Status.new(@actor_index, commands.size)
break

else
command_array = YE::REDUX::STATUS::IMPORTED_COMMANDS
next unless command_array.include?©
command_array = command_array[c]
next if command_array[0] and !$game_switches[command_array[1]]
index_list[c] = commands.size
commands.push(command_array[2])
end}
else
$scene = Scene_Menu.new(1)
end
end
#--------------------------------------------------------------------------
# * Switch to Next Actor Screen
#--------------------------------------------------------------------------
def next_actor
@actor_index += 1
@actor_index %= $game_party.members.size
$scene = Scene_Attributes.new(@actor_index)
end
#--------------------------------------------------------------------------
# * Switch to Previous Actor Screen
#--------------------------------------------------------------------------
def prev_actor
@actor_index += $game_party.members.size - 1
@actor_index %= $game_party.members.size
$scene = Scene_Attributes.new(@actor_index)
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
update_menu_background
@help_window.update
@attr_window.update
@status_window.update
@status2_window.update
@status2_window.refresh
if @info_window.visible
@info_window.update
@info_window.refresh(on_attribute)
if Input.trigger?(Input::A) or Input.trigger?(Input:: or Input.trigger?(Input::C)
@info_window.hide
end
elsif @confirm_window.active
@confirm_window.update
confirm_attr_selection
elsif @attr_window.active
update_attr_selection
end
end
#--------------------------------------------------------------------------
# * Update Attribute Selection
#--------------------------------------------------------------------------
def update_attr_selection
if Input.trigger?(Input::
Sound.play_cancel
return_scene
elsif Input.trigger?(Input::R)
Sound.play_cursor
next_actor
elsif Input.trigger?(Input::L)
Sound.play_cursor
prev_actor
elsif Input.trigger?(Input::A) and Info_window
@info_window.visible = true
elsif Input.trigger?(Input::C)
if @attr_window.on_attribute.nil?
Sound.play_buzzer
else
up = cost?(@attr_window.on_attribute.level)
points = @actor.attr_points
if points >= up and !@attr_window.on_attribute.maxed?
@attr_window.active = false
@confirm_window.show
else
Sound.play_buzzer
end
end
end
end

#--------------------------------------------------------------------------
# * Confirm Attribute Update
#--------------------------------------------------------------------------
def confirm_attr_selection
if Input.trigger?(Input::
Sound.play_cancel
@confirm_window.hide
@attr_window.active = true
elsif Input.trigger?(Input::C) and !@confirm_window.yes?
Sound.play_cancel
@confirm_window.hide
@attr_window.active = true
elsif Input.trigger?(Input::C) and @confirm_window.yes?
Sound.play_decision
@actor.upgrade_attr(@attr_window.on_attribute.id)
@attr_window.contents.clear
@attr_window.refresh
@status_window.refresh
@status2_window.refresh
@confirm_window.hide
@attr_window.active = true
end
end
end


#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================

class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * Display Gained Experience and Gold
#--------------------------------------------------------------------------
alias bonus_attr_points_display_exp_and_gold display_exp_and_gold
def display_exp_and_gold
bonus_attr_points_display_exp_and_gold
bonus = 0
$game_troop.members.each{ |enemy|
bonus += $data_enemies[enemy.enemy_id].bonus_points
}
$game_party.members.each{ |actor|
actor.attr_points += bonus
}
if bonus > 0
text = sprintf(Vocab::Bonus_Points, bonus)
text += "s" if bonus > 1
text += "."
$game_message.texts.push('\.' + text)
end
wait_for_message
end
end


class Attr_Info_Window < Window_Base

include Attibute_Def

def initialize(actor)
@actor = actor
super( 0, 104, 544, 416-104)
self.back_opacity = 256
end

def refresh(attribute)
create_contents

level = attribute.level
max_level = attribute.max_level
bonus = attribute.bonus

states = []
for st in attribute.states.keys
next if HIDE_S.include?(st)
states[st] = @actor.state_probability(st)
end

draw_icon(attribute.icon, 0, 0)
self.contents.draw_text(26, 0 , 260-26, WLH, attribute.name)
b = 0
for i in 0..5
case i
when 0
text = Vocab.hp
c = 0
when 1
text = Vocab.mp
c = WLH
when 2
text = Vocab.atk
c = 0
when 3
text = Vocab.def
c = WLH
when 4
text = Vocab.spi
c = 0
when 5
text = Vocab.agi
c = WLH
end
self.contents.font.color = system_color
self.contents.draw_text(b, WLH + c , 90, WLH, text)
text = ""
text += "+" if bonus[i] > 0
text += bonus[i].to_s
self.contents.font.color = text_color(0)
self.contents.draw_text(b, WLH + c , 75, WLH, text, 2)
b += 83 if c > 0
end

if !attribute.elements.keys.empty?

self.contents.font.color = text_color(17)
self.contents.draw_text(0, 0, 260, WLH * 7, "Elements", 1)
self.contents.font.color = text_color(0)

l = 0
for i in 0...$data_system.elements.size
next unless ELEMENT_ICONS.keys.include?(i)
next unless attribute.elements.keys.include?(i)
draw_icon(ELEMENT_ICONS[i], 0, WLH * (4 + l), true)
self.contents.draw_text(26, WLH * (4+l) , 240, WLH, $data_system.elements[i]+" damage")
damage = attribute.elements[i][0]
text = "Dealt"
self.contents.draw_text(0, WLH * (5+l) , 125, WLH, text)
text = sprintf("x%s", damage)
self.contents.draw_text(0, WLH * (5+l) , 120, WLH, text, 2)
defense = attribute.elements[i][1]
text = "Taken"
self.contents.draw_text(130, WLH * (5+l) , 125, WLH, text)
text = sprintf("x%s", defense)
self.contents.draw_text(130, WLH * (5+l) , 120, WLH, text, 2)
l += 2
end
end

unless states.empty?
self.contents.font.color = text_color(23)
self.contents.draw_text(0, WLH * (4+l), 260, WLH, "States", 1)
self.contents.font.color = text_color(0)
end
for i in 0...$data_states.size
unless states[i].nil?
text = $data_states[i].name + ": "
self.contents.draw_text(x+26, WLH * (5+l) , 248, WLH, text)
draw_icon($data_states[i].icon_index, x, WLH * (5+l), true)
unless 0 >= states[i]
text = sprintf("%s%% immunity", 100-states[i])
else
self.contents.font.color = text_color(2)
text = "Immune"
end
self.contents.draw_text(x, WLH * (5+l) , 248, WLH, text, 2)
self.contents.font.color = text_color(0)
l += 1
end
end

if attribute.skill_list[0] != []
self.contents.font.color = text_color(2)
self.contents.draw_text(260, 0, 260, WLH, "Skills", 1)
self.contents.font.color = text_color(0)
for i in 0...attribute.skill_list[0].size
skill = attribute.skill_list[0][i]
learnt = @actor.skills.include?($data_skills[skill])
draw_item_name($data_skills[skill], 260, WLH*(1+i), learnt)
z = sprintf("[level %s]", attribute.skill_list[1][i])
self.contents.draw_text(260, WLH*(1+i), 255, WLH, z, 2)
end
end
self.contents.font.color.alpha = 255

auto_skill = attribute.auto_skill
a_skill_chance = [[attribute.auto_skill_chance, 0].max, 100].min
if !auto_skill.nil?
l = attribute.skill_list[0].size
draw_item_name($data_skills[auto_skill], 260, WLH * (2 + l), true)
text = sprintf("%s%% chance of activating: ", a_skill_chance)
self.contents.draw_text(260, WLH*(1+l), 255, WLH, text, 0)
#~ if !attribute.required_auto_skill_element.nil? and ELEMENT_ICONS.include?(attribute.required_auto_skill_element)
#~ text = "Required weapon:"
#~ draw_icon(ELEMENT_ICONS[attribute.required_auto_skill_element], 480, WLH * (3+l))
#~ self.contents.draw_text(260, WLH*(3+l), 255, WLH, text, 0)
#~ end
end
text = sprintf("Max level: %s ",max_level)
if level == max_level
self.contents.font.color = text_color(14)
text = "Maxed out"
end
self.contents.draw_text(0, 0, 544, WLH, text, 1)
end
end


#==============================================================================
# ** Window_Attribute_Confirm
#------------------------------------------------------------------------------
# This class processes the window for confirming an attribue update
#==============================================================================

class Window_Attribute_Confirm < Window_Selectable

def initialize
super(172, 150, 200, 80)
@item_max = 2
@column_max = 2
self.index = 0
create_contents
self.contents.draw_text( 0, 0, 168, 24, "Confirm Upgrade?", 1)
self.contents.draw_text( 0, 24, 84, 24, "Yes", 1)
self.contents.draw_text( 84, 24, 84, 24, "No", 1)
end

def item_rect(index)
rect = Rect.new(0, 24, 84, 24)
rect.x = self.index * 84
return rect
end

def yes?
return (self.index == 0)
end

end # End: class Window_Attribute_Confirm < Window_Selectable

#==============================================================================
# ** Attribute
#------------------------------------------------------------------------------
# This class tranforms the Attributes' hash in ruby objects.
#==============================================================================

class Attribute

include Attibute_Def
# --------------------------------------
attr_reader :id
attr_reader :name
attr_reader :description
attr_reader :icon
attr_reader :max_level
attr_reader :level
# --------------------------------------

def initialize(id)
attribute = ATTRIBUTES[id]
@id = id
@name = attribute[0]
@bonus = attribute[1]
@elements = attribute[2]
@skills = attribute[3]
@auto_skill = attribute[4]
@description = attribute[5]
@states = attribute[6]
@icon = attribute[7]
@max_level = attribute[8]
@level = 0
end

def bonus
@bonus[-1] = [0,0,0,0,0,0]
level = @level
while @bonus[level].nil?
level -= 1
end
return @bonus[level]
end

def elements
@elements[-1] = {}
level = @level
while @elements[level].nil?
level -= 1
end
return @elements[level]
end

def skills
if @skills[@level].nil?
return []
else
return @skills[@level]
end
end

def auto_skill
@auto_skill[-1] = [nil,0] #,nil]
level = @level
while @auto_skill[level].nil?
level -= 1
break if level == -1
end
return @auto_skill[level][0]
end

def auto_skill_chance
@auto_skill[-1] = [nil,0] #,nil]
level = @level
while @auto_skill[level].nil?
level -= 1
break if level == -1
end
return [[@auto_skill[level][1],0].max,100].min
end

def states
@states[-1] = {}
level = @level
while @states[level].nil?
level -= 1
end
return @states[level]
end

def upgrade
@level += 1
@level = [@level, @max_level].min
end

def downgrade
@level -= 1
@level = [@level, 0].max
end

def maxed?
return (@level == @max_level)
end

def skill_list
result = [[],[]]
for l in 0..@max_level
next if @skills[l].nil?
for skill in @skills[l]
result[0].push(skill)
result[1].push(l)
end
end
return result
end
end # End: class Attribute


#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
# This is a superclass of all windows in the game.
#==============================================================================

class Window_Base < Window

def hide
self.visible = false
self.active = false
end

def show(activate = true)
self.visible = true
self.active = activate
end

end # End: class Window_Base < Window