Skillelement = Waffenelement + X

Drachentöter

Motto: Aufgeben ist es, was den Menschen tötet. Nur der Mensch, der sich weigert aufzugeben, hat sich das Recht verdient, auf dem glanzvollen Pfad der Menschheit zu wandeln.

Donnerstag, 6. November 2014, 16:18

Skillelement = Waffenelement + X

Ahoi,

ich suche eine Lösung für folgendes Problem:

Ein Held kann verschiedene Waffenarten tragen, diese haben Vor- und Nachteilen und benötigen dementsprechend
ein Element (Schwert, Axt, Dolch ...).
Nun sollen diese Vor- und Nachteile sich auch in den Elementen widerspiegeln.
=> In der Schadensberechnung sollen die Waffenelemente Einfluss auf die Skills haben.

Beispiele:
Held trägt Schwert (Element: SCHWERT).
Held setzt ,,Starker Hieb" ein => Element von ,,Starker Hieb" wird zu SCHWERT (eben das momentane Waffenelement).

Held trägt Axt (Element: AXT).
Held setzt ,,Erdstoß" ein (PDEF-F >0, MEDF-F =0).
,,Erdstoß" hat von Haus aus das Element ERDE.
=> ,,Erdstoß" hat nun die beiden Elemente: ERDE und AXT.

Allgemein gesagt:
Skill-Element = Skill- Element + Waffen- Element

Das ganze sollte optimalerweise nur bei Skills mit PDEF-F >0 bzw. MDEF-F = 0 wirken.
(denn einen ,,Feuerball" ist es egal, welche Waffe der Anwender trägt).

Ich verwende das Tankentai SBS mit umgeänderten Kampfformeln.
Weiß nicht, inwieweit in die Kampfformeln eingegriffen werden muss,
deshalb poste ich sie lieber mal dabei (Autor: Irrlicht).

KS- Formeln 1

Spoiler

#############
#
# "Modifizierte Schadensformeln für Enus SBS" - Script (Part 1/3)
# version 1.0d <Beta> (2nd October 2014)
# by Irrlicht <www.rpg-studio.org>
#
# # Beschreibung: ------------------------------------------------------------
# Dieses Script verändert die Schadensberechnung.
# Füge es unter den Scripts "Advanced Actor Status" und "Sideview 2" ein.
# Zuätzliche Änderungen:
# - Battler haben nun eine Schadensklasse (Game_Battler#damage_type)
# - Battler können schmetternd getroffen werden (Game_Battler#crushing)
# - Trefferchance von Gegnern (Game_Enemy) ist auf 95% gesenkt #
# - Gegner haben ein Level #
# -------------------------------------------------------------- #############

module N01

DAMAGE_CLASS_ELEMENT = 10 # Element ID zur Bestimmung der Schadensklasse
POP_CRUSH = "Schmetternd" # Textzusatz für Schmettertreffer

USE_ADVANCED_ACTOR_STATUS = true # "Advanced Actor Status" verwendet?

end

class Game_Battler

# --------------------------------------------------------------------------
# Mehrfach verwendete Formeln und Formelteile:
# --------------------------------------------------------------------------

# Schadensverringerung bei gegebenem Verteidigungswert (100% entspricht 1.0):
def damage_reduction(defense_value)
basis = 0.5 / (26 + 4 * self.level)
value = basis * defense_value
if value >= 0.65
value = 0.65 + 0.58 / (26+16*self.level) * (defense_value - 0.65 / basis)
end
return [value, 1.0].min
end

# Kritische Trefferchance bei gegebenem Attributwert (100% entspricht 1.0):
def action_crit_chance(user, crit_stat)
0.01 * [user.crt - self.rcrt, 1].max * 0.2 *
(5.0 + user.eva / (0.5 * user.level) + crit_stat / (5.0 + user.level * 6.0))
end

# --------------------------------------------------------------------------
# Angriffs-Formeln:
# --------------------------------------------------------------------------

# [Hauptformel] Angriffsschaden:
def attack_damage_value(user)
value = attack_base_damage(user)
value *= (1 - damage_reduction(self.pdef))
value *= 0.5 if user.second_attack # weniger Schaden beim zweiten Treffer
return value
end

# Grundschaden eines Angriffs:
def attack_base_damage(user)
case user.damage_type
when :str then 2.0*user.weapon_atk + 1.5 * user.str
when :dex then 2.0*user.weapon_atk + 1.0 * user.dex + 0.8 * user.str
when :agi then 2.0*user.weapon_atk + 1.0 * user.agi
when :int then 2.0*user.weapon_atk + 1.5 * user.str
end
end

# [Hauptformel] Schadensbonus bei kritischem Treffer:
def attack_crit_bonus(user)
1.0 * self.damage * (user.dmg - self.rdmg) / 100.0
end

# [Hauptformel] Zusätzlicher Schadensbonus bei Schmettertreffer:
def attack_crush_bonus(user)
1.0 * self.damage
end

# ---

# [Hauptformel] Trefferrate (100% entspricht 1.0)
def attack_hit_chance(user)
0.01 * (user.hit - 4.0 * self.agi / user.dex)
end

# [Hauptformel] Ausweichchance (100% entspricht 1.0)
def attack_eva_chance(user)
0.01 * (5.0 + self.eva / (0.5 * self.level) + self.agi / (5.0 * user.dex))
end

# [Hauptformel] Kritische Trefferchance (100% entspricht 1.0)
def attack_crit_chance(user)
action_crit_chance(user, user.dex)
end

# [Hauptformel] Schmettertrefferchance (100% entspricht 1.0)
def attack_crush_chance(user)
attack_crit_chance(user) / 10.0
end

# --------------------------------------------------------------------------
# Skill-Formeln:
# --------------------------------------------------------------------------

# Grundwirkung eines Skills:
def skill_base_damage(user, skill)
# - Power:
value = skill.power.abs
# - Attribute:
value += 2.0*user.atk * skill.atk_f / 100.0
value += user.str * skill.str_f / 100.0
value += user.dex * skill.dex_f / 100.0
value += user.agi * skill.agi_f / 100.0
value += user.int * skill.int_f / 100.0
# - Bonus durch Schadensklasse:
case user.damage_type
when :str then value += 0.5 * user.str * skill.str_f / 100.0
when :int then value += 1.0 * user.int * skill.int_f / 100.0
end
# - Vorzeichen wiederherstellen:
value = -value if skill.power < 0
return value
end

# [Hauptformel] Skillschaden/heilung:
def skill_damage_value(user, skill)
# - Basiswirkung:
value = skill_base_damage(user, skill)
# - Schadensreduktion:
if skill.pdef_f > 0
value *= 1 - damage_reduction(self.pdef * skill.pdef_f / 100.0)
end
if skill.mdef_f > 0
value *= 1 - damage_reduction(self.mdef * skill.mdef_f / 100.0)
end
return value
end

# [Hauptformel] Kritischer Schadensbonus:
def skill_crit_bonus(user, skill)
0.5 * attack_crit_bonus(user)
end

# [Hauptformel] Zusätzlicher Schadensbonus bei Schmettertreffer:
def skill_crush_bonus(user, skill)
0.5 * attack_crush_bonus(user)
end

# ---

# [Hauptformel] Trefferchance (100% entspricht 1.0, ohne Hit-Rate des Skills):
def skill_hit_chance(user, skill)
if skill.magic?
1.0
else
attack_hit_chance(user)
end
end

# [Hauptformel] Ausweichchance (100% entspricht 1.0):
def skill_eva_chance(user, skill)
attack_eva_chance(user) * skill.eva_f / 100.0
end

# [Hauptformel] Kritische Trefferchance (100% entspricht 1.0):
def skill_crit_chance(user, skill)
crit_stat = skill.magic? ? user.int : user.dex
return action_crit_chance(user, crit_stat)
end

# [Hauptformel] Schmettertrefferchance (100% entspricht 1.0):
def skill_crush_chance(user, skill)
skill_crit_chance(user, skill) / 10.0
end

end

zum Lesen den Text mit der Maus markieren

KS- Formeln 2

Spoiler

#############
#
# "Modifizierte Schadensformeln für Enus SBS" - Script (Part 2/3)
# version 1.0d <Beta> (2nd October 2014)
# by Irrlicht <www.rpg-studio.org>
#
# # Contents: ---------------------------------------------------------------
# Dieses Script verändert die Schadensberechnung. #
# Füge es unter den Scripts "Advanced Actor Status" und "Sideview 2" ein. #
# -------------------------------------------------------------- #############

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# EXTENSION: Redefine Damage Calculation Process
#==============================================================================

class Game_Battler

attr_accessor :crushing # Crushing Blow indicator flag

#-------------------------------------------------------------------------
# * Game_Battler#weapon_atk
# Determine the battlers current weapon based attack power.
#-------------------------------------------------------------------------
def weapon_atk
result = base_weapon_atk
@states.each { |id| result *= $data_states[id].atk_rate / 100.0 }
return result.to_i
end

#-------------------------------------------------------------------------
# * Game_Battler#base_weapon_atk
# Determine the battlers current basic weapon attack power.
#-------------------------------------------------------------------------
def base_weapon_atk
if USE_ADVANCED_ACTOR_STATUS and actor? and weapons.length >= 2
i = second_attack ? 1 : 0 # Weapon Index
factor = Use_Old_Two_Sword_Beahave ? TWO_SWORDS_STYLE : Dual_Attack_Power
result = (weapons[i].atk + @set_atk / 2) * factor / 100.0
return [[result.to_i, 0].max, Actor_Max_Atk].min
else
return base_atk
end
end

#-------------------------------------------------------------------------
# Stat Replacements when they are not defined by "Advanced Actor Status"
#-------------------------------------------------------------------------
define_method(:dmg) { 100 } unless method_defined?(:dmg)
define_method(:rdmg) { 0 } unless method_defined?(:rdmg)
define_method(:crt) { 5 } unless method_defined?(:crt)
define_method(:rcrt) { 0 } unless method_defined?(:rcrt)

#-------------------------------------------------------------------------

#-------------------------------------------------------------------------
# Game_Battler#clear_result_variables
# Clear effect result. Used within skill/attack effect calculations.
#-------------------------------------------------------------------------
def clear_result_variables
self.critical = self.crushing = @missed = @evaded = false
end

#-------------------------------------------------------------------------
# Game_Battler#success?
# Return current success status of an skill/attack effect.
#-------------------------------------------------------------------------
def success?
not (@missed or @evaded)
end

#-------------------------------------------------------------------------
# Game_Battler#correct_result_variables
# Correct damage value and critical flag after an attack/skill effect.
#-------------------------------------------------------------------------
def correct_result_variables
self.critical = false unless success?
self.damage = POP_EVA if @evaded
self.damage = POP_MISS if @missed
self.damage = nil unless $game_temp.in_battle
end

#-------------------------------------------------------------------------
# Game_Battler#set_second_attack
# Try to switch to the second weapon after an attack effect.
#-------------------------------------------------------------------------
def set_second_attack
if USE_ADVANCED_ACTOR_STATUS and actor?
wset = weapons
self.second_attack = true if wset[0] != nil and wset[1] != nil
end
end

#-------------------------------------------------------------------------
# Game_Battler#normalize_damage
# Round fractional damage values.
#-------------------------------------------------------------------------
def normalize_damage
self.damage = (self.damage + rand).to_i if self.damage.is_a?(Numeric)
end

#-------------------------------------------------------------------------

#-------------------------------------------------------------------------
# Game_Battler#attack_effect
# REDEFINE: Use new formulas for calculation, fix evade.
#-------------------------------------------------------------------------
def attack_effect(attacker) #EDIT
process_attack_effect(attacker, false)
end

#-------------------------------------------------------------------------
# Game_Battler#perfect_attack_effect
# REDEFINE: Use new formulas for calculation, fix evade.
#-------------------------------------------------------------------------
def perfect_attack_effect(attacker) #EDIT
process_attack_effect(attacker, true)
end

#-------------------------------------------------------------------------
# Game_Battler#process_attack_effect
# Replacement for the old attack effect.
#-------------------------------------------------------------------------
def process_attack_effect(attacker, perfect)
clear_result_variables
set_attack_first_hit(attacker) unless perfect
set_attack_result(attacker) if success?
@evaded = false if perfect
set_attack_state_change(attacker) if success?
correct_result_variables
attacker.set_second_attack
return true
end

#-------------------------------------------------------------------------
# Game_Battler#set_attack_first_hit
#-------------------------------------------------------------------------
def set_attack_first_hit(attacker)
@missed = (rand >= attack_hit_chance(attacker))
end

#-------------------------------------------------------------------------
# Game_Battler#set_attack_damage_value
# REDEFINE
#-------------------------------------------------------------------------
def set_attack_damage_value(attacker)
self.damage = attack_damage_value(attacker)
self.damage *= elements_correct(attacker.element_set) / 100.0
normalize_damage
end

#-------------------------------------------------------------------------
# Game_Battler#set_attack_hit_value
# REDEFINE
#-------------------------------------------------------------------------
def set_attack_hit_value(attacker)
@evaded = (self.damage >= 0 and not self.cant_evade?)
@evaded &&= (rand < attack_eva_chance(attacker))
end

#-------------------------------------------------------------------------
# Game_Battler#set_attack_critical
# REDEFINE
#-------------------------------------------------------------------------
def set_attack_critical(attacker)
self.critical = (rand < attack_crit_chance(attacker))
self.crushing = (critical and rand < attack_crush_chance(attacker))
end

#-------------------------------------------------------------------------
# Game_Battler#set_critical_damage
# REDEFINE
#-------------------------------------------------------------------------
def set_critical_damage(attacker)
self.damage += attack_crit_bonus(attacker)
self.damage += attack_crush_bonus(attacker) if self.crushing
normalize_damage
end

#-------------------------------------------------------------------------

#-------------------------------------------------------------------------
# Game_Battler#skill_effect_n01
# REDEFINE: Use new formulas for calculation, fix evade.
# Modified Alias from the "Sideview 2" - script:
# def skill_effect(user, skill)
#-------------------------------------------------------------------------
def skill_effect_n01(user, skill)
process_skill_effect(user, skill, false)
end

#-------------------------------------------------------------------------
# Game_Battler#perfect_skill_effect_n01
# REDEFINE: Use new formulas for calculation, fix evade.
# Modified Alias from the "Sideview 2" - script:
# def perfect_skill_effect(user, skill)
#-------------------------------------------------------------------------
def perfect_skill_effect_n01(user, skill) #EDIT
process_skill_effect(user, skill, true)
end

#-------------------------------------------------------------------------
# Game_Battler#process_skill_effect
#-------------------------------------------------------------------------
def process_skill_effect(user, skill, perfect)
clear_result_variables
return false unless skill_valid?(skill)
effective = (skill.common_event_id > 0)
effective |= set_skill_first_hit(user, skill) unless perfect
effective |= set_skill_result(user, skill, effective) if success?
@evaded = false if perfect
effective |= set_skill_state_change(user, skill, effective) if success?
correct_result_variables
return effective
end

#-------------------------------------------------------------------------
# Game_Battler#skill_valid?
#-------------------------------------------------------------------------
def skill_valid?(skill)
not (self.hp == 0 ? [3, 4] : [5, 6]).include?(skill.scope)
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_first_hit
#-------------------------------------------------------------------------
def set_skill_first_hit(user, skill)
miss_chance = 1 - set_skill_hit(user, skill) * skill.hit / 100.0
@missed = (rand < miss_chance)
return (miss_chance > 0)
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_hit
# REDEFINE
#-------------------------------------------------------------------------
def set_skill_hit(user, skill)
skill_hit_chance(user, skill)
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_result
# REDEFINE
#-------------------------------------------------------------------------
def set_skill_result(user, skill, effective) #EDIT
set_skill_damage_value(user, skill)
if self.damage > 0
self.damage /= 2 if self.guarding?
set_skill_critical(user, skill)
set_skill_critical_damage(user, skill) if self.critical
end
apply_variance(skill.variance) if skill.variance > 0 and self.damage.abs > 0
effective |= set_skill_hit_value(user, skill, effective)
return effective
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_critical
#-------------------------------------------------------------------------
def set_skill_critical(user, skill)
self.critical = (rand < skill_crit_chance(user, skill))
self.crushing = (critical and rand < skill_crush_chance(user, skill))
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_critical_damage
#-------------------------------------------------------------------------
def set_skill_critical_damage(user, skill)
self.damage += skill_crit_bonus(user, skill)
self.damage += skill_crush_bonus(user, skill) if self.crushing
normalize_damage
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_damage_value
# REDEFINE
#-------------------------------------------------------------------------
def set_skill_damage_value(user, skill)
self.damage = skill_damage_value(user, skill)
self.damage *= elements_correct(skill.element_set) / 100.0
normalize_damage
end

#-------------------------------------------------------------------------
# Game_Battler#set_skill_hit_value
# REDEFINE
#-------------------------------------------------------------------------
def set_skill_hit_value(user, skill, effective)
if self.damage < 0 or self.cant_evade?
@evaded = false
return effective
else
evade_chance = skill_eva_chance(user, skill)
@evaded = (rand < evade_chance)
return (effective or evade_chance > 0)
end
end
end

zum Lesen den Text mit der Maus markieren

KS- Formeln 3

Spoiler

#############
#
# "Modifizierte Schadensformeln für Enus SBS" - Script (Part 3/3)
# version 1.0d <Beta> (2nd October 2014)
# by Irrlicht <www.rpg-studio.org>
#
# # Contents: ---------------------------------------------------------------
# Dieses Script verändert die Schadensberechnung. #
# Füge es unter den Scripts "Advanced Actor Status" und "Sideview 2" ein. #
# -------------------------------------------------------------- #############

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# EXTENSION: Define a main damage class for each battler.
#==============================================================================

class Game_Battler

#---------------------------------------------------------------------------
# Game_Battler#damage_type
# Return the name of the attribute this battler is specialized on.
#---------------------------------------------------------------------------
def damage_type
case element_rank(DAMAGE_CLASS_ELEMENT)
when 3 then :str # [C]
when 4 then :dex # [D]
when 5 then :agi # [E]
when 6 then :int # [F]
else :str # Other
end
end
end

#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# EXTENSION: Define level, change hit rate, element rank table access
#==============================================================================

class Game_Enemy

#---------------------------------------------------------------------------
# Game_Enemy#element_rank
# Return the specified element rank of the enemy.
#---------------------------------------------------------------------------
def element_rank(index)
$data_enemies[@enemy_id].element_ranks[index]
end

#---------------------------------------------------------------------------
# Game_Enemy#level
# Return an enemies level.
#---------------------------------------------------------------------------
def level
$data_enemies[@enemy_id].level
end

#---------------------------------------------------------------------------
# Game_Enemy#hit
# OVERRIDDEN: Change the enemies default hit chance to 95%
#---------------------------------------------------------------------------
def hit
(super * 0.95).round
end
end

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# EXTENSION: element rank table access
#==============================================================================

class Game_Actor

#---------------------------------------------------------------------------
# Game_Actor#element_rank
# Return the specified element rank of the actor.
#---------------------------------------------------------------------------
def element_rank(index)
$data_classes[@class_id].element_ranks[index]
end
end

#==============================================================================
# ** RPG::Enemy
#------------------------------------------------------------------------------
# EXTENSION: Define level
#==============================================================================

class RPG::Enemy

attr_writer :level # An enemies defined level

#---------------------------------------------------------------------------
# RPG::Enemy#name
# ALIASED: Extract the enemies level before returning the name.
#---------------------------------------------------------------------------
unless method_defined?(:name_ILC_extract_level)
alias_method(:name_ILC_extract_level, :name)
end
def name
extract_level_from_name unless defined?(@level)
name_ILC_extract_level
end

#---------------------------------------------------------------------------
# RPG::Enemy#level
# Extract and return the enemies level.
#---------------------------------------------------------------------------
def level
extract_level_from_name unless defined?(@level)
return @level
end

#---------------------------------------------------------------------------
# RPG::Enemy#extract_level_from_name
# Try to extract the enemies new level from its name.
#---------------------------------------------------------------------------
def extract_level_from_name
@name.slice!(/\s*\[\s*(\d+)\s*\]\s*/)
@level = $1 != nil ? $1.to_i : 1
end
end

#==============================================================================
# ** RPG::Enemy
#------------------------------------------------------------------------------
# EXTENSION: Redefine Damage Popup
#==============================================================================

class RPG::Sprite

attr_writer :critical_text # Critical Text

#---------------------------------------------------------------------------
# RPG::Sprite#critical_text
# Return critical text message
#---------------------------------------------------------------------------
def critical_text
@critical_text || POP_CRI
end

#---------------------------------------------------------------------------
# RPG::Sprite#damage
# REDEFINE: Alter critical text message
#---------------------------------------------------------------------------
def damage(value, critical, sp_damage = nil)
dispose_damage(0...@_damage_durations.size)
@_damage_sprites = []
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
@damage_size = 1 if !MULTI_POP
@damage_size = damage_string.size if MULTI_POP
for i in 0...@damage_size
letter = damage_string[i..i] if MULTI_POP
letter = damage_string if !MULTI_POP
bitmap = Bitmap.new(160, 4
bitmap.font.name = DAMAGE_FONT
bitmap.font.size = DMG_F_SIZE
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, 12-1,160, 36, letter, 1)
bitmap.draw_text(+1, 12-1,160, 36, letter, 1)
bitmap.draw_text(-1, 12+1,160, 36, letter, 1)
bitmap.draw_text(+1, 12+1,160, 36, letter, 1)
if value.is_a?(Numeric) and value < 0
bitmap.font.color.set(HP_REC_COLOR[0],HP_REC_COLOR[1],HP_REC_COLOR[2]) if !sp_damage
bitmap.font.color.set(SP_REC_COLOR[0],SP_REC_COLOR[1],SP_REC_COLOR[2]) if sp_damage
else
bitmap.font.color.set(HP_DMG_COLOR[0],HP_DMG_COLOR[1],HP_DMG_COLOR[2]) if !sp_damage
bitmap.font.color.set(SP_DMG_COLOR[0],SP_DMG_COLOR[1],SP_DMG_COLOR[2]) if sp_damage
bitmap.font.color.set(CRT_DMG_COLOR[0],CRT_DMG_COLOR[1],CRT_DMG_COLOR[2]) if critical
end
bitmap.draw_text(0, 12,160, 36, letter, 1)
if critical and CRITIC_TEXT and i == 0
x_pop = (MULTI_POP ? (damage_string.size - 1) * (DMG_SPACE / 2) : 0)
bitmap.font.size = ((DMG_F_SIZE * 2) / 3).to_i
bitmap.font.color.set(0, 0, 0)
#bitmap.draw_text(-1 + x_pop, -1, 160, 20, POP_CRI, 1)
#bitmap.draw_text(+1 + x_pop, -1, 160, 20, POP_CRI, 1)
#bitmap.draw_text(-1 + x_pop, +1, 160, 20, POP_CRI, 1)
#bitmap.draw_text(+1 + x_pop, +1, 160, 20, POP_CRI, 1)
#bitmap.font.color.set(CRT_TXT_COLOR[0],CRT_TXT_COLOR[1],CRT_TXT_COLOR[2]) if critical
#bitmap.draw_text(0 + x_pop, 0, 160, 20, POP_CRI, 1)
text = critical_text
bitmap.draw_text(-1 + x_pop, -1, 160, 20, text, 1)
bitmap.draw_text(+1 + x_pop, -1, 160, 20, text, 1)
bitmap.draw_text(-1 + x_pop, +1, 160, 20, text, 1)
bitmap.draw_text(+1 + x_pop, +1, 160, 20, text, 1)
bitmap.font.color.set(CRT_TXT_COLOR[0],CRT_TXT_COLOR[1],CRT_TXT_COLOR[2]) if critical
bitmap.draw_text(0 + x_pop, 0, 160, 20, text, 1)
#--- EDIT
end
if critical and CRITIC_FLASH
$game_screen.start_flash(Color.new(255, 255, 255, 255),10)
end
@_damage_sprites[i] = ::Sprite.new(self.viewport)
@_damage_sprites[i].bitmap = bitmap
@_damage_sprites[i].ox = 80
@_damage_sprites[i].oy = 20
@_damage_sprites[i].x = self.x + i * DMG_SPACE
@_damage_sprites[i].y = self.y - self.oy / 2
@_damage_sprites[i].z = DMG_DURATION + 3000 + i * 2
end
end
end

#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
# EXTENSION: Redefine Damage Popup
#==============================================================================

class Sprite_Battler

#---------------------------------------------------------------------------
# Sprite_Battler#damage_pop
# ALIASED: Alter critical damage text.
#---------------------------------------------------------------------------
unless method_defined?(:damage_pop_ILC_define_crit_text)
alias_method(:damage_pop_ILC_define_crit_text, :damage_pop)
end
def damage_pop(*args)
self.critical_text = POP_CRUSH if @battler.crushing
damage_pop_ILC_define_crit_text(*args)
self.critical_text = nil
end
end

zum Lesen den Text mit der Maus markieren