I'm using RTAB system, and er GUILLAUME777's Multi-Slot script. I think they're the relevant ones.
If I have 2 weapons or (2atks) in an item name, I can make a character attack twice in a turn.
But he'll run up, attack, return, run up, attack return. So he's basically attacking fully twice.
Is there a complimentary script or adjustment I can make so that a character runs up, and swings twice, so i can 2 damages/numbers, then returns, without having to run again?
Also I have TONNES of tiny little questions like this one that I'd like to ask, but it feels inappropriate to clog up here with them.
Is there a more suitable place/forum for asking lots of little questions?
CODE
#==============================================================================
# Multi-slot equipment script
#------------------------------------------------------------------------------
# Section 2: Actor
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.1
# 2006/02/14
#==============================================================================
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles the actor. It's used within the Game_Actors class
# ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
include G7_MS_MOD
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :equip_mode # To restore equipment after false equip
attr_accessor :equip_type_force # To bypass equip_type
attr_accessor :equip_from_menu # To prevent users to unequip cursed items
attr_accessor :translucent_texts # To store translucents slots
#--------------------------------------------------------------------------
# * Setup (Initializing new Slots)
# actor_id : actor ID
#--------------------------------------------------------------------------
alias g7_ms_game_actor_setup setup
def setup(actor_id)
g7_ms_game_actor_setup(actor_id) #setup normaly
self.order_armor_ids
end
#--------------------------------------------------------------------------
# * Number of Offhand Required
# ignore : ignore
#--------------------------------------------------------------------------
def nb_offhand_required(ignore=nil)
nb_offhand = 0
nb_need_offhand = 0
for i in 0...self.weapon_slots.size
if i != ignore then
weapon = self.weapon_ids[i]
if weapon == 0 then
nb_offhand += 1
elsif $data_weapons[weapon].needs_offhand then
nb_need_offhand += 1
else
nb_offhand += 1
end
end
end
return (nb_need_offhand - nb_offhand)
end
#--------------------------------------------------------------------------
# * Change Equipment ( Modified for extra equipment)
# equip_type : type of equipment
# id : weapon or armor ID (If 0, remove equipment)
#--------------------------------------------------------------------------
alias g7_ms_game_actor_equip equip
def equip(equip_type, id)
if @equip_type_force != nil then equip_type = @equip_type_force end
# equip_type_force is used to bypass the equip_type argument
if self.equip_mode == 'STORE' then
# Store equipment for it to be restored after checking what the stats would
self.equip_mode = nil
@stored_armors = self.armor_ids.dup
@stored_weapons = self.weapon_ids.dup
saved_mode = 'STORE'
elsif self.equip_mode == 'RESTORE'
# Restore equipment after preview of new equipment on stats
self.equip_mode = nil
self.restore(equip_type)
return
# If equipped for real
else
if self.enough_hands?(equip_type,id) != false then
# Switch items to be equipped to fool the players
id = self.switch_items(equip_type,id)
end
end
# If not enough hands then don't equip
if self.enough_hands?(equip_type,id) == false then
id = 0
# If cursed and player tried to remove it, do nothing
elsif self.equip_from_menu and self.cursed?(equip_type) then
id = 0
# If the slot is one of the 5 basic ones
elsif equip_type <= 4
# Equip the goold old way
g7_ms_game_actor_equip(equip_type, id)
else
# Equip in the new way
equip_extra(equip_type,id) #equip in the new way
end
# Fix in case there are no enough empty hands for all the equipped weapons
if id != 0 then self.fix_handed_weapons(equip_type) end
# This ensure that the next equiping will restore the original equipment
if saved_mode == 'STORE' then self.equip_mode = 'RESTORE' end
end
#--------------------------------------------------------------------------
# * Restore Equipment once the stats are checked and adds translucent
# equip_type : type of equipment
#--------------------------------------------------------------------------
def restore(equip_type)
if self.translucent_texts == nil then self.translucent_texts = Array.new end
self.equip_from_menu = false
if equip_type != 0 and @stored_weapons[0] != self.weapon_ids[0]
self.translucent_texts[0] = true
end
for i in 1...@stored_weapons.size
if i+[self.armor_slots.size,4].max != equip_type and
@stored_weapons[i] != self.weapon_ids[i] then
self.translucent_texts[i] = true
end
end
for i in 0...@stored_armors.size
if i+1 != equip_type and
@stored_armors[i] != self.armor_ids[i] then
self.translucent_texts[self.weapon_slots.size + i] = true
end
end
@equip_type_force = nil
copy = self.translucent_texts.dup
self.weapon_ids = @stored_weapons
self.armor_ids = @stored_armors
self.translucent_texts = copy
end
#--------------------------------------------------------------------------
# * Switch Items. Switches equipment to fool a player.
# equip_type : type of equipment
# id : id
#--------------------------------------------------------------------------
def switch_items(equip_type,id)
if self.cursed?(equip_type) == false then
if equip_type == 0 or equip_type > [self.armor_slots.size,4].max
for i in 0...SWITCH_EQUIP_WEAPONS.size
if SWITCH_EQUIP_WEAPONS[i][0] == id then
$game_party.lose_weapon(SWITCH_EQUIP_WEAPONS[i][0], 1)
$game_party.gain_weapon(SWITCH_EQUIP_WEAPONS[i][1], 1)
id = SWITCH_EQUIP_WEAPONS[i][1]
end
end
else
for i in 0...SWITCH_EQUIP_ARMORS.size
if SWITCH_EQUIP_ARMORS[i][0] == id then
$game_party.lose_armor(SWITCH_EQUIP_ARMORS[i][0], 1)
$game_party.gain_armor(SWITCH_EQUIP_ARMORS[i][1], 1)
id = SWITCH_EQUIP_ARMORS[i][1]
end
end
end
end
return id
end
#--------------------------------------------------------------------------
# * Enough Hands? Returns if there are enough hands to hold a weapon
# equip_type : type of equipment
# id : ID
#--------------------------------------------------------------------------
def enough_hands?(equip_type, id)
# Enough Hand = true if you unequip something
if id == 0 then return true end
# If it's a weapon
if equip_type == 0 or equip_type > [self.armor_slots.size ,4].max
nb = $data_weapons[id].nb_hands
elsif self.weapon_shield_share and self.armor_slots[equip_type-1] == self.shield_hand_slot
nb = 1
else
return true #return true if not shield or weapon
end
nb_s = 0 #nb shield slots
if self.shield_hand_wield then
for i in 0...self.armor_slots.size
if self.armor_slots[i] == self.shield_hand_slot
if self.weapon_shield_share != true then nb_s += 1 end
if self.cursed?(i+1) then nb += 1 end
end
end
end
if self.weapon_hand_wield
if self.cursed?(0) then # Penalities if can't remove first weapon
nb = nb + $data_weapons[self.weapon_ids[0]].nb_hands
end
for i in 1...self.weapon_slots.size # Penalities if cant remove weapon
if self.cursed?(self.armor_slots.size + i)
nb = nb + $data_weapons[self.weapon_ids[i]].nb_hands
end
end
end
if nb == 1 then # If it only takes 1 hand to hold
return true
elsif nb > nb_s+1 and self.weapon_hand_wield != true
return false
elsif nb > self.weapon_slots.size+ nb_s and self.weapon_hand_wield
return false
elsif self.shield_hand_wield != true and self.weapon_hand_wield != true
return false
else
return true
end
end
#--------------------------------------------------------------------------
# * Equip Weapon
# index : Index of weapon
# id : weapon ID (If 0, remove equipment)
#--------------------------------------------------------------------------
def equip_weapon(index,id)
if index == 0 then
self.equip(0, id)
else
self.equip([self.armor_slots.size, 4].max + index, id)
end
end
#--------------------------------------------------------------------------
# * Equip Armor
# index : Index of armor
# id : armor ID (If 0, remove equipment)
#--------------------------------------------------------------------------
def equip_armor(index, id)
self.equip(index+1, id)
end
#--------------------------------------------------------------------------
# * Equip Extra Items
# equip_type : Index of item being equipped
# id : ID if either armor or weapon (If 0, remove equipment)
#--------------------------------------------------------------------------
def equip_extra(equip_type,id)
# If its an extra armor slot
if equip_type <= [self.armor_slots.size,4].max
if id == 0 or $game_party.armor_number(id) > 0
update_auto_state($data_armors[self.armor_ids[equip_type-1]], $data_armors[id])
$game_party.gain_armor(self.armor_ids[equip_type-1], 1)
self.armor_ids[equip_type-1] = id
$game_party.lose_armor(id, 1)
end
# If its a weapon slot
else
if id == 0 or $game_party.weapon_number(id) > 0
equip_type = equip_type - [self.armor_slots.size, 4].max
weapon = self.weapon_ids[equip_type]
if weapon != nil then
$game_party.gain_weapon(weapon, 1)
end
self.weapon_ids[equip_type] = id
$game_party.lose_weapon(id, 1)
end
end
end
#--------------------------------------------------------------------------
# * Fix Multi-Handed Weapons
# equip_keep : ID of weapon to keep
#--------------------------------------------------------------------------
def fix_handed_weapons(equip_keep=nil)
array_wield_hands = Array.new # Stores the slot of the weapon that
# needs empty hands
nb_emp_hands = 0 # Store nb of empty hands
penalities = 0 # Stores extra hand required
save_force = @equip_type_force
save_menu = @equip_from_menu
@equip_from_menu = false
@equip_type_force = nil
if self.shield_hand_wield
for narmor in 0...self.armor_slots.size
if self.armor_slots[narmor] == self.shield_hand_slot
if self.weapon_shield_share == true then
penalities += 1
end
if self.armor_ids[narmor] == 0 then
nb_emp_hands += 1 # Stores empty shield hand
end
end
end
end
for nweapon in 0...self.weapon_slots.size
if self.weapon_ids[nweapon] == 0
if self.weapon_hand_wield then
nb_emp_hands += 1
end
else
array_wield_hands.push(nweapon) # Stores the hand to wield weapon
end
end
for nweapon in Rg(array_wield_hands.size-1, 0, -1)
if self.weapon_ids[array_wield_hands[nweapon]] != 0 then
nb_hands = $data_weapons[self.weapon_ids[array_wield_hands[nweapon]]].nb_hands
nb_hands += penalities
penalities = 0
save_hands = nb_hands
end
# If it finds an empty hand
while nb_emp_hands != 0 and nb_hands > 1
# Decrease the counter
nb_hands += -1
nb_emp_hands += -1
end
#if shield needs to be removed for empty hand
if self.shield_hand_wield then
for namor in 0...self.armor_slots.size
if nb_hands > 1 and self.armor_ids[namor] != 0 and
self.armor_slots[namor] == self.shield_hand_slot and
namor+1 != equip_keep and self.cursed?(namor+1) == false then
nb_hands += -1
self.equip(namor+1,0)
end
end
end
#if it must remove weapons to make room for empty hands
if self.weapon_hand_wield == true then
for nhand in Rg(self.weapon_slots.size-1, 0, -1)
if nb_hands > 1 and self.weapon_ids[nhand] != 0
if nhand == 0 then
if equip_keep != 0 and self.cursed?(0) == false then
n = nb_emp_hands
nb_emp_hands += $data_weapons[self.weapon_ids[nhand]].nb_hands
n = nb_emp_hands - n
self.equip(0,0)
end
else
if nhand+[self.armor_slots.size,4].max != equip_keep and
self.cursed?(nhand+[self.armor_slots.size,4].max) == false
then
if nhand < array_wield_hands[nweapon] then
nb_emp_hands += 1
else
nb_emp_hands += $data_weapons[self.weapon_ids[nhand]].nb_hands
end
self.equip([self.armor_slots.size,4].max+nhand, 0)
end
end # End of ( if nhnad == 0 )
end # End of ( if nb_hands != 1 )
while nb_emp_hands != 0 and nb_hands > 1
#if it finds empty hand
nb_hands += -1 #decrease counter
nb_emp_hands += -1
end
end # End of ( for nahand )
end # End of ( if self.weapon )
# If still can't find a slot, remove the weapon
if nb_hands > 1
if array_wield_hands[nweapon] == 0 and self.cursed?(0) == false then
nb_emp_hands = 1 + nb_emp_hands + save_hands - nb_hands
self.equip(0, 0)
elsif self.cursed?(array_wield_hands[nweapon]+[self.armor_slots.size,4].max) == false and
array_wield_hands[nweapon] != 0 then
nb_emp_hands = 1 + nb_emp_hands + save_hands - nb_hands
self.equip(array_wield_hands[nweapon]+[self.armor_slots.size,4].max,0)
end
end
# If it finds an empty hand
while nb_emp_hands != 0 and nb_hands > 1
# Decrease the counter
nb_hands += -1
nb_emp_hands += -1
end
# If STILL not enough hands
if nb_hands > 1 then
# Remove the item the user tried to equip
self.equip(equip_keep,0)
end
end
@equip_type_force = save_force # Returns old equip_type_force
@equip_from_menu = save_menu # Return old equip_from_menu
end
#--------------------------------------------------------------------------
# * Cursed Items
# equip_type : ID if either armor or weapon
#--------------------------------------------------------------------------
def cursed?(equip_type)
if equip_type == 0
weapon_id = self.weapon_ids[0]
if weapon_id != 0 and $data_weapons[weapon_id].cursed then return true end
# If Armor
elsif equip_type <= self.armor_slots.size
armor_id = self.armor_ids[equip_type - 1]
if armor_id != 0 and $data_armors[armor_id].cursed then return true end
else
weapon_id = self.weapon_ids[equip_type - [self.armor_slots.size, 4].max]
if weapon_id != nil and weapon_id != 0 and $data_weapons[weapon_id].cursed then return true end
end
return false
end
#--------------------------------------------------------------------------
# * Remove all cursed items
#--------------------------------------------------------------------------
def remove_curse
self.equip_type_force = nil
for i in 0...(self.weapon_slots.size + self.armor_slots.size)
if self.cursed?(i) then self.equip(i,0) end
end
end
#--------------------------------------------------------------------------
# * Order Armor IDs for Slots
#--------------------------------------------------------------------------
def order_armor_ids
equipment_array = Array.new
for i in 0...self.armor_ids.size
if self.armor_ids[i] != nil and self.armor_ids[i] != 0
kind = $data_armors[self.armor_ids[i]].kind
if equipment_array[kind] == nil then
equipment_array[kind] = Array.new
end
equipment_array[kind].push(self.armor_ids[i])
#array in which 0 = array for shield, 1 = array for helmet,
#2 = array for armor and 3 = array for accessory, etc
end
end
self.armor_ids = nil # Remove all armors
armors = Array.new
for i in 0...self.armor_slots.size
aitem = nil
if equipment_array[(self.armor_slots[i])-1] == nil then
equipment_array[(self.armor_slots[i])-1] = Array.new
end
while aitem == nil and equipment_array[(self.armor_slots[i])-1].size != 0
aitem = equipment_array[(self.armor_slots[i])-1].delete_at(0)
if aitem == 0 then aitem = nil end
end
if aitem != nil then
armors.push(aitem) # Adds armor
else
armors.push(0) # Adds empty
end # End of ( if iaitem != nil )
end # End of ( for i in )
self.armor_ids = armors
end
#--------------------------------------------------------------------------
# * Change Weapon Slots
# array : Array for weapon slots
#--------------------------------------------------------------------------
def weapon_slots=(array) # Change slots of weapons
if array == nil then array = WEAPON_KINDS end # Use default slots
weapon_array = Array.new(self.weapon_ids) # Save weapons
self.weapon_ids = nil
@weapon_slots = Array.new(array) # New slots
self.weapon_ids = weapon_array # Re-equip items
i = self.weapon_ids.size
while self.nb_offhand_required > 1
if self.weapon_ids[i] != nil and self.weapon_ids[i] != 0 then
self.equip_weapon(i,0)
end
i = i-1
end
end
#--------------------------------------------------------------------------
# * Change Armor Slots
# array : Array for armor slots
#--------------------------------------------------------------------------
def armor_slots=(array) # change slots of armor
if array == nil then array = ARMOR_KINDS end #returns to default if nothing
equipment_array = Array.new
for i in 0...[array.max, self.armor_slots.max].max+1
if equipment_array[i] == nil then
equipment_array[i] = Array.new
end
end
for i in 0...self.armor_ids.size
if self.armor_ids[i] != nil and self.armor_ids[i] != 0 then
kind = $data_armors[self.armor_ids[i]].kind + 1
equipment_array[kind].push(self.armor_ids[i])
# Array in which 0 = array for shield, 1 = array for helmet,
# 2 = array for armor and 3 = array for accessory, etc
end
end
for kind in 0...[array.max, self.armor_slots.max].max+1
if array.include?(kind) and self.armor_slots.include?(kind) then
nb_i_new = 0
nb_i_old = 0
for i in 0...self.armor_slots.size
if self.armor_slots[i] == kind then nb_i_old += 1 end
end
for i in 0...array.size
if array[i] == kind then nb_i_new += 1 end
end
for i in nb_i_new...nb_i_old
for k in 0...equipment_array[kind].size
index = equipment_array[kind].index(0)
if index != nil then
equipment_array[kind].delete_at(index)
end
end
end
end
end
self.armor_ids = nil # Remove items
@armor_slots = array # New array
for i in 0...self.armor_slots.size
aitem = nil
kind = self.armor_slots[i]
if equipment_array[kind].size != 0
aitem = equipment_array[kind].delete_at(0)
self.equip(i+ 1,aitem) # Adds armor
else
self.equip(i+ 1,0)
end
end
end
#--------------------------------------------------------------------------
# * Set new array of weapons, if nil then it removes all weapon
# array : Array of weapon IDs
#--------------------------------------------------------------------------
def weapon_ids=(array) # Be careful. @item_type_force needs to be nil!
if array == nil then
self.equip(0, 0) # Remove first weapon
for i in 1...self.weapon_ids.size
self.equip(i + [self.armor_slots.size,4].max, 0 ) # Remove all weapons
end
return
end
self.weapon_ids = nil
for i in 0...self.weapon_slots.size
# Ensure no weapons are equipped
if array[i] == nil then array[i] = 0 end
if i == 0 then # If first weapon
self.equip(0, array[i]) # Equip weapon
else # Else if extra weapons
self.equip(i + [self.armor_slots.size, 4].max, array[i])
end
end
end
#--------------------------------------------------------------------------
# * Set new array of armors in ordered fashion
# array : Array of armor IDs
#--------------------------------------------------------------------------
def armor_ids=(array)
if array == nil then
for i in 0...self.armor_slots.size
self.equip(i + 1, 0) # Remove all armors
end
return
end
self.armor_ids = nil # Remove all armors
for i in 0...self.armor_slots.size
self.equip(i+ 1, array[i]) # Adds armor
end
end
#--------------------------------------------------------------------------
# * Return @armor_ids
#--------------------------------------------------------------------------
def armor_ids
# Returns ids with all armor, also store 4 armor
unless self.is_a?(Game_Actor)
return []
end
if @armor_ids == nil then @armor_ids = Array.new(self.armor_slots.size) end
ids = @armor_ids
ids[0] = @armor1_id
ids[1] = @armor2_id
ids[2] = @armor3_id
ids[3] = @armor4_id
# Ensure no nil values are returned
for i in 0...self.armor_slots.size
if ids[i] == nil then ids[i] = 0 end
end
return ids
end
#--------------------------------------------------------------------------
# * Return @Weapon_ids
#--------------------------------------------------------------------------
def weapon_ids
# Returns ids with all weapon, also store first weapon
unless self.is_a?(Game_Actor)
return []
end
if @weapon_ids == nil then @weapon_ids = Array.new(self.weapon_slots.size) end
ids = @weapon_ids
ids[0] = @weapon_id
# Ensure no nil values are returned
for i in 0...self.weapon_slots.size
if ids[i] == nil then ids[i] = 0 end
end
return ids
end
#--------------------------------------------------------------------------
# * Returns names of armor
#--------------------------------------------------------------------------
def armor_slot_names
# Return custom words for slots, or default ones
if @armor_slot_names == nil then @armor_slot_names = Array.new end
temp_array = Array.new(@armor_slot_names)
# Default names of slots
default_names = [$data_system.words.armor1,$data_system.words.armor2,$data_system.words.armor3,$data_system.words.armor4, self.extra_slot_names].flatten #default names of slots
for i in 0...default_names.size
if temp_array[i] == nil then temp_array[i] = default_names[i] end # If not
# Custom then set as default
if temp_array[i] == nil then temp_array[i] = $data_system.words.armor4 end
end
return temp_array
end
#--------------------------------------------------------------------------
# * Returns names of weapons
#--------------------------------------------------------------------------
def weapon_slot_names
# Return custom words for weapon slots, of default ones
if @weapon_slot_names != nil then
temp_array = Array.new(@weapon_slot_names) # Use the custom values
else
temp_array = Array.new(self.weapon_slots.size) # Use default values
end
default_names = WEAPON_KIND_NAMES # Default names of slots
for i in 0...self.weapon_slots.size
# If... Set as Constant
if temp_array[i] == nil then temp_array[i] = default_names[i] end
if temp_array[i] == nil then temp_array[i] = $data_system.words.weapon end
# If constant array is empty then use default one
end
return temp_array
end
#--------------------------------------------------------------------------
# * Return all element of all equipped armor
#--------------------------------------------------------------------------
def guard_element_set
# Return array with guard_element_set of all equipped armor
set = []
# Search all armor equipped
for id in self.armor_ids
next if id.nil?
armor = $data_armors[id]
# Add the element to set
set += (armor != nil ? armor.guard_element_set : [])
end
return set
end
#--------------------------------------------------------------------------
# * Return all equipment
#--------------------------------------------------------------------------
def equipments
# Return array with all equipment
equipments = []
self.weapon_ids.each {|id| equipments.push($data_weapons[id])}
self.armor_ids.each {|id| equipments.push($data_armors[id])}
return equipments
end
#--------------------------------------------------------------------------
# * Return if item is equiped
#--------------------------------------------------------------------------
def equiped?(item)
# Return if item is equipped, works with both armor and weapon
case item
when RPG::Weapon
return self.weapon_ids.include?(item.id)
when RPG::Armor
return self.armor_ids.include?(item.id)
else
return false
end
end
#--------------------------------------------------------------------------
# * Return list of weapons to use for attacks
#--------------------------------------------------------------------------
def attacks # This return an array with the list of all attacks of a character
# This takes in consideration extra weapon + number of attacks of
# each weapon
attacks = Array.new
for i in 0...self.weapon_ids.size
weapon = $data_weapons[self.weapon_ids[i]]
# If the weapon is valid
if weapon != nil and weapon.atk != 0 then
for counter in 0...weapon.nb_attacks
attacks.push(i) #add attacks
end
end
end
# Give one unarmed attack if no weapons on
if attacks.size == 0 then attacks[0] = 0 end
return Array.new(attacks)
end
#--------------------------------------------------------------------------
# * Get the weapon to be used in attack
#--------------------------------------------------------------------------
def get_weapon_data
# This returns the weapon to use for the attack.
weaponid = self.weapon_ids[self.attacks[self.attack_count]]
weapon = $data_weapons[weaponid]
return weapon
end
#--------------------------------------------------------------------------
# * Get Offensive Animation ID for Normal Attacks
#--------------------------------------------------------------------------
def animation1_id
# Set animation for current weapon
weapon = self.get_weapon_data
return weapon != nil ? weapon.animation1_id : 0
end
#--------------------------------------------------------------------------
# * Get Target Animation ID for Normal Attacks
#--------------------------------------------------------------------------
def animation2_id
# Set animation for current weapon
weapon = self.get_weapon_data
return weapon != nil ? weapon.animation2_id : 0
end
#--------------------------------------------------------------------------
# * Get Basic Attack Power
# Get the atk to be used in attack ( or shown in menu screen )
#--------------------------------------------------------------------------
def base_atk
multiplier = nil
if $game_temp.in_battle and (self.current_action.kind == 0 or self.all_weapons_for_skills? != true)
# If in battle & doing a normal attack, only use one weapon's attack power
weapon = self.get_weapon_data
n = weapon != nil ? weapon.atk : 0
# Multiplier of hand as defined in self.weapon_slot_powers
if weapon != nil and weapon.nb_hands == 1 then
multiplier = self.weapon_slot_powers[self.attacks[self.attack_count]]
end
if multiplier == nil then multiplier = 100 end
n = n * (multiplier/100.0)
else # Use cumulative attack power of all weapons if in status screen or
# if using skill and all_weapons_for_skills == true
n = 0
for i in 0...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
atk = weapon != nil ? weapon.atk : 0
if weapon != nil and weapon.nb_hands == 1 then
multiplier = self.weapon_slot_powers[i]
else
multiplier = nil
end
if multiplier == nil then multiplier = 100 end
atk = atk * (multiplier/100.0)
n += atk
end
end
nb_weap = 0
for i in 0...self.weapon_slots.size
if self.weapon_ids[i] != nil and self.weapon_ids[i] != 0
nb_weap = nb_weap + 1
end
end # Penality if more than 1 weapon
penality = self.multi_weapons_penality != nil ? self.multi_weapons_penality : 0
penality = penality /100.0
if nb_weap > 1 then n = n * ( 1 - penality ) end
return n
end
#--------------------------------------------------------------------------
# * Get Normal Attack Element
#--------------------------------------------------------------------------
def element_set
# Return elemental set of the current weapon
weapon = self.get_weapon_data
return weapon != nil ? weapon.element_set : []
end
#--------------------------------------------------------------------------
# * Get Normal Attack State Change (+)
#--------------------------------------------------------------------------
def plus_state_set
# Status the weapon can give
weapon = self.get_weapon_data
return weapon != nil ? weapon.plus_state_set : []
end
#--------------------------------------------------------------------------
# * Get Normal Attack State Change (-)
#--------------------------------------------------------------------------
def minus_state_set
# Status the weapon can remove
weapon = self.get_weapon_data
return weapon != nil ? weapon.minus_state_set : []
end
#--------------------------------------------------------------------------
# * Determine State Guard
# state_id : state ID
#--------------------------------------------------------------------------
def state_guard?(state_id)
# Return state defense of all armor
for i in self.armor_ids
armor = $data_armors[i]
if armor != nil
if armor.guard_state_set.include?(state_id)
return true
end
end
end
return false
end
#--------------------------------------------------------------------------
# * Get Element Revision Value
# element_id : element ID
#--------------------------------------------------------------------------
alias g7_ms_game_actor_element_rate element_rate
def element_rate(element_id)
result = g7_ms_game_actor_element_rate(element_id)
# Methods calculate bonus of extra weapon and armor
if self.armor_slots.size > 4
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
if armor != nil and armor.guard_element_set.include?(element_id)
result /= 2
end
end
end
return result
end
#--------------------------------------------------------------------------
# * Get Basic Strength
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_str base_str
def base_str
n = g7_ms_game_actor_base_str
for i in 1...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
n += weapon != nil ? weapon.str_plus : 0
end
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.str_plus : 0
end
return n
end
#--------------------------------------------------------------------------
# * Get Basic Dexterity
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_dex base_dex
def base_dex
n = g7_ms_game_actor_base_dex
for i in 1...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
n += weapon != nil ? weapon.dex_plus : 0
end
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.dex_plus : 0
end
return n
end
#--------------------------------------------------------------------------
# * Get Basic Agility
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_agi base_agi
def base_agi
n = g7_ms_game_actor_base_agi
for i in 1...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
n += weapon != nil ? weapon.agi_plus : 0
end
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.agi_plus : 0
end
return n
end
#--------------------------------------------------------------------------
# * Get Basic Intelligence
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_int base_int
def base_int
n = g7_ms_game_actor_base_int
for i in 1...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
n += weapon != nil ? weapon.int_plus : 0
end
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.int_plus : 0
end
return n
end
#--------------------------------------------------------------------------
# * Get Basic Physical Defense
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_pdef base_pdef
def base_pdef
n = g7_ms_game_actor_base_pdef
for i in 1...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
n += weapon != nil ? weapon.pdef : 0
end
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.pdef : 0
end
return n
end
#--------------------------------------------------------------------------
# * Get Basic Magic Defense
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_mdef base_mdef
def base_mdef
n = g7_ms_game_actor_base_mdef
for i in 1...self.weapon_slots.size
weapon = $data_weapons[self.weapon_ids[i]]
n += weapon != nil ? weapon.mdef : 0
end
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.mdef : 0
end
return n
end
#--------------------------------------------------------------------------
# * Get Basic Evasion Correction
#--------------------------------------------------------------------------
alias g7_ms_game_actor_base_eva base_eva
def base_eva
n = g7_ms_game_actor_base_eva
for i in 4...self.armor_slots.size
armor = $data_armors[self.armor_ids[i]]
n += armor != nil ? armor.eva : 0
end
return n
end
#--------------------------------------------------------------------------
# * Reset all slot data to default one
#--------------------------------------------------------------------------
def reset_all_slots
self.armor_slots = nil
self.weapon_slots = nil
self.armor_slot_names = nil
self.weapon_slot_names = nil
self.extra_slot_names = nil
self.weapon_slot_powers = nil
self.shield_hand_wield = nil
self.weapon_hand_wield = nil
self.shield_hand_slot = nil
self.weapon_shield_share = nil
self.multi_weapons_penality = nil
self.ignore_offhand = nil
self.all_weapons_for_skills = nil
end
#--------------------------------------------------------------------------
# * Returns behavior of items on character
#--------------------------------------------------------------------------
def weapon_shield_share
return @weapon_shield_share != nil ? @weapon_shield_share : WEAPON_SHIELD_SHARE
end
def weapon_slots
return @weapon_slots != nil ? @weapon_slots : WEAPON_KINDS
end
def armor_slots
return @armor_slots != nil ? @armor_slots : ARMOR_KINDS
end
def shield_hand_wield
return @shield_hand_wield != nil ? @shield_hand_wield : SHIELD_HAND_WIELD
end
def multi_weapons_penality
return @multi_weapons_penality != nil ? @multi_weapons_penality : MULTI_WEAPONS_PENALITY
end
def weapon_slot_powers
return @weapon_slot_powers != nil ? @weapon_slot_powers : WEAPON_KIND_POWERS
end
def weapon_hand_wield
return @weapon_hand_wield != nil ? @weapon_hand_wield : WEAPON_HAND_WIELD
end
def shield_hand_slot
return @shield_hand_slot != nil ? @shield_hand_slot : SHIELD_HAND_SLOT
end
def extra_slot_names
return @extra_slot_names != nil ? @extra_slot_names : EXTRA_SLOT_NAMES
end
def ignore_offhand?
return @ignore_offhand != nil ? @ignore_offhand : IGNORE_OFFHAND
end
def attack_count
# Returns number of attacks already made
return @attack_count != nil ? @attack_count : 0
end
def all_weapons_for_skills?
return @all_weapons_for_skills != nil ? @all_weapons_for_skills : ALL_WEAPONS_FOR_SKILLS
end
#--------------------------------------------------------------------------
# * Change behavior of items on character
#--------------------------------------------------------------------------
def multi_weapons_penality=(value)
@multi_weapons_penality = value
end
def weapon_slot_powers=(value)
@weapon_slot_powers = value
end
def weapon_shield_share=(bool)
@weapon_shield_share = bool
end
def shield_hand_slot=(int)
@shield_hand_slot = int
end
def shield_hand_wield=(bool)
@shield_hand_wield = bool
end
def weapon_hand_wield=(bool)
@weapon_hand_wield = bool
end
def ignore_offhand=(bool)
@ignore_offhand = bool
end
def all_weapons_for_skills=(bool)
@all_weapons_for_skills = bool
end
def attack_count=(value)
# Set number of attacks already made
@attack_count = value
end
#--------------------------------------------------------------------------
# * Change names for your slots
#--------------------------------------------------------------------------
def shield_name=(text)
# Set the shield slot name with...
# $game_actors[numberofactor].shield_name = 'Yourname'
@armor_slot_names[0] = text
end
def helmet_name=(text)
@armor_slot_names[1] = text
end
def armor_name=(text)
@armor_slot_names[2] = text
end
def accessory_name=(text)
@armor_slot_names[3] = text
end
def extra_slot_names=(array)
@extra_slot_names = array
end
def armor_slot_names=(array)
# Set a new array of names.
@armor_slot_names = array
end
def weapon_slot_names=(array)
# Set a new array of weapon names.
@weapon_slot_names = array
end
#--------------------------------------------------------------------------
# * End of CLASS: Game Actor
#--------------------------------------------------------------------------
end
#==============================================================================
# ** Game_Actors
#------------------------------------------------------------------------------
# This class handles the actor array. Refer to "$game_actors" for each
# instance of this class.
#==============================================================================
class Game_Actors
#--------------------------------------------------------------------------
# * Order Items
#--------------------------------------------------------------------------
def order_items
for actor in 0...@data.size
if @data[actor] != nil and @data[actor] != 0 then
# Order armors
@data[actor].order_armor_ids
end
end
end
#--------------------------------------------------------------------------
# * End of CLASS: Game Actors
#--------------------------------------------------------------------------
end
Games
Resources
RPG Maker VX
RPG Maker XP
Scripts
Tutorials
Downloads
Is there a way to make an attack double SWING, not double attack?, Also a question about questions.
Submit Your Article
Aug 10 2011, 04:56 PM
