Skriptproblem

[Expresseon]

Dies ist ein Appell an die Skriptmeister der Community!
Ich verwende eine große Zahl an Skripts in einem Projekt. Diese wurden 1:1 aus einer Demo kopiert. Allerdings trifft dieser Fehler auf:
Situation: Ein Kampf beginnt. Man agiert, doch wenn der Gegner an die Reihe kommt, tritt ein RGSS-Fehler auf: [Game Battler (nicht die normalen 3 Skripte, sonder ein spezielles anderes - sollte aber als unwichtig für den Fehler gelten, da es in der Demo ja funktioniert)] NoMethodError - undefinied method `find_skill_index' for #<Game_Enemy:0x136e678>. Tja, eben ein NoMethod Fehler, den ich nicht verstehen kann. Ich weiß jetzt nicht in wie fern das mit den anderen Skripts zusammenhängen kann. Ich bitte um eine Erklärung des NoMethodError. Wie könnte ich eine passende Methode definieren und wo?

[Expresseon]

Kann mir niemand helfen? o.O (was ne Frage)
Es ist ziemlich wichtig, da ich sonst eigentlich das ganze Projekt aufgeben kann. Bitte um Hilfe. :(

[Caine Luveno]

Definition einer "Method" (Methode):

Eine "Method" englisch für Methode bzw. allgemein beim Programmieren auch als Funktion oder Function (englisch) bekannt bezeichnet die Zusammenführung meherer Befehle zu einem Befehl (einer sogenannten Funktion). Die Funktion liefert in den meisten Fällen dann einen Rückgabewert mit dem weiter gearbeitet werden kann. Funktionen oder eben Methoden werden meistens dann eingesetzt wenn bestimmte Programmteile mehrfach genutzt werden oder es mithilfe von Funktionen kompakter und einfacher verständlich wird.

Definition des NoMethod Fehlers:

Mit dem Wissen was eine Methode ist, und das sie erst irgendwo festgelegt werden muss damit man sie verwenden kann, sowie ein bischen Englisch erklärt sich der Fehler von selber:

NoMethodError - undefinied method `find_skill_ index' for #<Game_Enemy:0x136e678>

"undefinied method" bedeutet in dem Sinne soviel wie: es wird eine Methode/Funktion aufgerufen die nirgends deklariert (festgelegt) wurde und Ruby von daher unbekannt ist. Des weiteren kann man der Fehlermeldung entnehmen das es sich um die Funktion "find_skill_index" handelt.

Lösung? recht einfach: durchsuch mal die Scripte in der Demo und in deinem Projekt nach der Funktionsdeklaration. Oder schau ob du nicht irgendeinen Teil vergessen hast zu kopieren.

Mit deinen sonstigen Scripten die du zu dem Kampfscript zusätzlich eingebaut hast wird das denke ich wenig zu tun haben da ich nicht glaube das eines dieser Scripte die Funktion wiede entfernt.

[Expresseon]

Danke für die ausführliche Hilfe.
Tja die Methode ist in einem Skript, nach dem Fehlerskript definiert:

#--------------------------------------------------------------------------
# * Find Skill Index
#--------------------------------------------------------------------------
def find_skill_index(skill)
for i in 0..@skills.size
if @skills[i] == skill.id
return i
end
end
return 0
end

Als Hinweis: Der Gegner kann mehrere Skills, man selber keine. Könnte es daran liegen? Denn die Methode wird ja definiert, alles ist genauso wie in der Demo, deshalb denke ich mir, dass es am Spiel selbst liegen könnte.

[Kelven]

Wenn du den Text der Fehlermeldung 1:1 kopiert hast, dann befindet sich hinter dem zweiten Unterstrich ein Leerzeichen (wodurch der Methodenaufruf natürlich eine nicht vorhandene Methode aufruft). Nachdem du den Fehler im Script verbessert hast, sollte alles funktionieren.

[Caine Luveno]

Danke für die ausführliche Hilfe.
Tja die Methode ist in einem Skript, nach dem Fehlerskript definiert:


Das könnte der Fehler sein. Soweit ich weiss werden die Scripte von oben nach unten ausgeführt, d.h. das Script welches ganz oben steht wird zuerst ausgeführt und das Main-Script welches ganz unten steht als letztes.

Es könnte also daran liegen das die Definition der Funktion erst nach dem ersten Aufruf erfolgt und Ruby diese deswegen als unbekannt definiert. Du könntest mal versuchen das Script mit der Funktionsdefinition VOR das Script welches dieFunktion aufruft (und ja den Fehler verursacht) zu verschieben

[Expresseon]

@ Kelven:
Das Leerzeichen ist mein Fehler beim Posten gewesen. :p

@ Caine Luveno:
Ich glaube, das Spielt keine Rolle, mit der Reihenfolge. Ich habe es geändert, aber nichts hat sich gebessert.

Dieser Fehler scheint mir langsam richtig unheimlich...

[Kelven]

Dann poste doch mal den Teil vom Code, in dem find_skill_index benutzt wird.

[Expresseon]

def skill_effect(user, skill)
skill_index = user.find_skill_index(skill)
# Clear critical flag
self.critical = false
# If skill scope is for ally with 1 or more HP, and your own HP = 0,
# or skill scope is for ally with 0, and your own HP = 1 or more
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
# End Method
return false
end

Ich kann auch noch mehr posten. Aber eigentlich müssten die ersten beiden Zeilen alles sagen, denn der Fehler betrifft laut RGSS die 2., hier gepostete Zeile.

[Kelven]

Und find_skill_index ist von welcher Klasse eine Funktion? Bzw. welcher Klasse gehört user an?

[-KD-]

Die Methode müsste laut Fehlermeldung in Game_Enemy oder Game_Battler definiert sein. Davon mal abgesehn ergibt die Methode aber keinen Sinn. Es gibt wesentlich elegantere Lösungen als diese hässlichen For-Schleifen-Konstruktionen.


skill_index = user.skills.find {|skill_id| skill_id == skill} or 0

Möglich wäre auch:

skill_index = if user.skills.include?(skill) then skill else 0 end

Diese beiden Zeilen machen jeweils das Gleiche wie deine Methode. Setz also statt dem Methodenaufruf einfach eine der beiden Zeilen ein.

[Kelven]

@-KD-
Also die letzte Zuweisung dürfte aber falsch sein, wenn ich mich nicht irre. skill_index ist anscheined eine Integer-Variable, skill ist aber so wie es bei P-Games' Zitat aussieht ein Objekt. Soweit ich das richtig sehe, wird bei P-Games' Beispiel das Array der Skills durchlaufen und geschaut, ob ein Skill die gleiche ID hat, wie der mit dem die Funktion aufgerufen wird. Dann wird i zurückgegeben und damit die Position vom Skill innerhalb des Arrays.

Edit:
Bei der ersten Zuweisung bin ich mir auch nicht sicher. find wird nach der Hilfedatei vom XP so definiert:



Returns the first item that tested as true during the block evaluation. If no item was true, returns nil.


Bei deinem Beispiel würde dann ein skill-Objekt zurückgegeben werden und nicht dessen ID. Und funktioniert das mit "or 0" wirklich? Bei mir wird das im XP ignoriert und die Variable auf nil gesetzt, falls kein Objekt gefunden wurde.

[Expresseon]

-KD-, die beiden Beispiele haben nicht funktioniert. Ich habe das erste ausprobiert, dieses mal war die Methode "skills" undefiniert (laut RGSS).
Beim zweiten Beispiel wird das Spiel sofort zu Kampfbeginn geschlossen. Könntet ihr nochmal genau beschreiben, was definiert werden muss?

[Kelven]

Ich nehme mal an find_skill_index ist ein Teil der Actor-Klasse, oder? Deswegen kann dort auch auf @skills zugegriffen werden, was in der Klasse Game_Battler nicht direkt funktioniert. Aber der Code von dem Zitat (also die ursprüngliche "find_skill_index"-Funktion) ist vermutlich auch nicht falsch. Der Fehler muss irgendwo anders liegen.

[Expresseon]

find_skill_index ist in Game_Battler untergebracht. Natürlich ist diese Klasse anders als normalerweise, es ist ja schließlich verändert. Ich nehme halt immer an, dass es am Spiel liegt und nicht an den Skripten, da es ja in der DEmo einwandfrei funktioniert.

[-KD-]

Also standardmäßig ist @skills ein Array aus Integervariablen. Standardmäßig hat Game_Actor auch eine Reader-Methode dafür. Demzufolge müsste mein Code standardmäßig auch richtig sein *g* Nun kenne ich P-Games Code nicht, kann also auch nicht sagen wie es bei ihm sein müsste. Ein erster Anlaufpunkt wäre ja schon, die Fehlermeldung zu erfahren.


Und funktioniert das mit "or 0" wirklich?
Jap, Ruby überprüft bei einer Or-Verknüpfung erstmal nur das erste Objekt. Wenn das nicht false und nicht nil ist, hört er auf, ansonsten überprüft er das zweite Objekt. Rückgabewert ist also immer das zuletzt geprüfte Objekt.
variable = objekt or standardwert
ist also eine einfache Lösung um einer Variable entweder ein Objekt, oder, wenn dieses nil ist, einen Standardwert zuzuweisen.

Edit: Autsch, es muss natürlich wegen der Bindung || statt or heißen. Oder man verwendet Klammern ^^°

[Kelven]

Aber was macht denn nun die ursprüngliche find_skill_index-Funktion? Die bekommt skill übergeben und da dort auf skill.id zugegriffen wird, nehme ich mal an, dass skill ein Objekt der Skill-Klasse ist. Dann wird mit der Schleife geschaut, ob diese id irgendwo bei den Skills des Charakters ist und falls ja,wird die Position im Array des Skills ausgegeben.

Müßte dein zweites Beispiel dann nicht so lauten?


skill_index = if user.skills.include?(skill.id) then user.skills.index(skill.id) else 0 end

[-KD-]

Naja, das ist halt das Problem. Man kann schwer einem Fehler auf die Spur kommen, wenn man den Code nicht kennt. Normalerweise wird in den Standardklassen nur mit der ID, nicht mit dem eigentlichen Objekt gehandelt. Wenn es in diesem Fall andersherum ist (im obigen Code steht ja tatsächlich skill.id) dann hast du natürlich recht.

skill_index = user.skills.index(skill.id) || 0

[Expresseon]

Ich glaube auch, dass es so wie Kelven es sagt, sein muss, wenn auch immernoch "skills" als undefinierte Methode ausgegeben wird. In der Originaldemo funktioniert es schließlich so, wie ich es gepostet habe.

[-KD-]

Ich weiß doch nicht wie deine Game_Battler Klasse aussieht. Damit es funktioniert, muss jeder Battler über eine Reader-Methode skills verfügen. Im Normallfall hat nur der Game_Actor sowas. Du kannst das theoretisch mit diesem Code ändern, aber wenn das nicht funktioniert, dann poste doch einfach deinen Code.

class Game_Enemy
def skills
$data_enemies[@enemy_id].actions.find_all {|action| action.kind == 1}.collect {|skillaction|
$data_skills[skillaction.skill_id]
}
end
end

[Expresseon]

Liegt es eigentlich wirklich an den Skills oder könnte es ewas mit den zusätzlichen Fähigkeiten, die ich verwende zu tun haben. Dises erhalten zu Beginn der Klasse jeweils einen Reader.


class Game_Battler
attr_reader :ap # AP
attr_reader :abilities # abilities
attr_reader :enabled_abilities # ability enabled

Dies betrifft allerdings nur den Hero und keinen Enemy...

[-KD-]

Wenn du von Actors und Enemies Skills herauslesen willst, müssen diese ja auch eine entsprechende skill-Methode besitzen. Hast du meinen vorherigen Post denn mal ausprobiert?
*nochmal subtil darauf hinweis, dass der einfachste Weg einfach das Posten deiner Scripte wäre*

[Expresseon]

Hast du meinen vorherigen Post denn mal ausprobiert?

Ich habe deine Klasse als neues Skript probiert, ebenso in das Fehlerskript am Ende eingebaut. Der selbe Fehler. Anderen Einbauvorschlag?


*nochmal subtil darauf hinweis, dass der einfachste Weg einfach das Posten deiner Scripte wäre*

Gut, bedenke aber:


Ich verwende eine große Zahl an Skripten...


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

class Game_Battler
attr_reader :ap # AP
attr_reader :abilities # abilities
attr_reader :enabled_abilities # ability enabled
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
@battler_name = ""
@battler_hue = 0
@hp = 0
@sp = 0
@states = []
@states_turn = {}
@maxhp_plus = 0
@maxsp_plus = 0
@str_plus = 0
@dex_plus = 0
@agi_plus = 0
@int_plus = 0
@hidden = false
@immortal = false
@damage_pop = false
@damage = nil
@critical = false
@animation_id = 0
@animation_hit = false
@white_flash = false
@blink = false
@current_action = Game_BattleAction.new

@abilities = []
@enabled_abilities = []
end
#--------------------------------------------------------------------------
# * Get Strength (STR)
#--------------------------------------------------------------------------
def str
n = [[base_str + @str_plus, 1].max, 999].min
for i in @states
n *= $data_states[i].str_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].str_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# * Get Dexterity (DEX)
#--------------------------------------------------------------------------
def dex
n = [[base_dex + @dex_plus, 1].max, 999].min
for i in @states
n *= $data_states[i].dex_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].dex_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# * Get Agility (AGI)
#--------------------------------------------------------------------------
def agi
n = [[base_agi + @agi_plus, 1].max, 999].min
for i in @states
n *= $data_states[i].agi_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].agi_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# * Get Intelligence (INT)
#--------------------------------------------------------------------------
def int
n = [[base_int + @int_plus, 1].max, 999].min
for i in @states
n *= $data_states[i].int_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].int_rate / 100.0
end
n = [[Integer(n), 1].max, 999].min
return n
end
#--------------------------------------------------------------------------
# * Set Maximum HP
# maxhp : new maximum HP
#--------------------------------------------------------------------------
def maxhp=(maxhp)
@maxhp_plus += maxhp - self.maxhp
@maxhp_plus = [[@maxhp_plus, -9999].max, 9999].min
@hp = [@hp, self.maxhp].min
end
#--------------------------------------------------------------------------
# * Set Maximum SP
# maxsp : new maximum SP
#--------------------------------------------------------------------------
def maxsp=(maxsp)
@maxsp_plus += maxsp - self.maxsp
@maxsp_plus = [[@maxsp_plus, -9999].max, 9999].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# * Set Strength (STR)
# str : new Strength (STR)
#--------------------------------------------------------------------------
def str=(str)
@str_plus += str - self.str
@str_plus = [[@str_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# * Set Dexterity (DEX)
# dex : new Dexterity (DEX)
#--------------------------------------------------------------------------
def dex=(dex)
@dex_plus += dex - self.dex
@dex_plus = [[@dex_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# * Set Agility (AGI)
# agi : new Agility (AGI)
#--------------------------------------------------------------------------
def agi=(agi)
@agi_plus += agi - self.agi
@agi_plus = [[@agi_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# * Set Intelligence (INT)
# int : new Intelligence (INT)
#--------------------------------------------------------------------------
def int=(int)
@int_plus += int - self.int
@int_plus = [[@int_plus, -999].max, 999].min
end
#--------------------------------------------------------------------------
# * Get Hit Rate
#--------------------------------------------------------------------------
def hit
n = 100
for i in @states
n *= $data_states[i].hit_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].hit_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# * Get Attack Power
#--------------------------------------------------------------------------
def atk
n = base_atk
for i in @states
n *= $data_states[i].atk_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].atk_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# * Get Physical Defense Power
#--------------------------------------------------------------------------
def pdef
n = base_pdef
for i in @states
n *= $data_states[i].pdef_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].pdef_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# * Get Magic Defense Power
#--------------------------------------------------------------------------
def mdef
n = base_mdef
for i in @states
n *= $data_states[i].mdef_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].mdef_rate / 100.0
end
return Integer(n)
end
#--------------------------------------------------------------------------
# * Get Evasion Correction
#--------------------------------------------------------------------------
def eva
n = base_eva
for i in @states
n += $data_states[i].eva
end
return n
end
#--------------------------------------------------------------------------
# * Change HP
# hp : new HP
#--------------------------------------------------------------------------
def hp=(hp)
@hp = [[hp, maxhp].min, 0].max
# add or exclude incapacitation
for i in 1...$data_states.size
if $data_states[i].zero_hp
if self.dead?
add_state(i)
else
remove_state(i)
end
end
end
end
#--------------------------------------------------------------------------
# * Change SP
# sp : new SP
#--------------------------------------------------------------------------
def sp=(sp)
diff = sp - @sp
if diff < 0
for i in @enabled_abilities
diff *= $data_abilities[i].sp_cost_rate / 100.0
end
end

@sp = [[Integer(@sp + diff), maxsp].min, 0].max
end
#--------------------------------------------------------------------------
# * Recover All
#--------------------------------------------------------------------------
def recover_all
@hp = maxhp
@sp = maxsp
for i in @states.clone
remove_state(i)
end
end
#--------------------------------------------------------------------------
# * Get Current Action
#--------------------------------------------------------------------------
def current_action
return @current_action
end
#--------------------------------------------------------------------------
# * Determine Action Speed
#--------------------------------------------------------------------------
def make_action_speed
@current_action.speed = agi + rand(10 + agi / 4)
end
#--------------------------------------------------------------------------
# * Decide Incapacitation
#--------------------------------------------------------------------------
def dead?
return (@hp == 0 and not @immortal)
end
#--------------------------------------------------------------------------
# * Decide Existance
#--------------------------------------------------------------------------
def exist?
return (not @hidden and (@hp > 0 or @immortal))
end
#--------------------------------------------------------------------------
# * Decide HP 0
#--------------------------------------------------------------------------
def hp0?
return (not @hidden and @hp == 0)
end
#--------------------------------------------------------------------------
# * Decide if Command is Inputable
#--------------------------------------------------------------------------
def inputable?
return (not @hidden and restriction <= 1)
end
#--------------------------------------------------------------------------
# * Decide if Action is Possible
#--------------------------------------------------------------------------
def movable?
return (not @hidden and restriction < 4)
end
#--------------------------------------------------------------------------
# * Decide if Guarding
#--------------------------------------------------------------------------
def guarding?
return (@current_action.kind == 0 and @current_action.basic == 1)
end
#--------------------------------------------------------------------------
# * Decide if Resting
#--------------------------------------------------------------------------
def resting?
return (@current_action.kind == 0 and @current_action.basic == 3)
end
#--------------------------------------------------------------------------
# * Get Maximum AP
#--------------------------------------------------------------------------
def maxap
return 2 * @level
end
#--------------------------------------------------------------------------
# * Change AP
# ap : new AP
#--------------------------------------------------------------------------
def ap=(ap)
@ap = [[ap, maxap].min, 0].max
end
#--------------------------------------------------------------------------
# * Learn Ability
# state_id : state ID
#--------------------------------------------------------------------------
def learn_ability(ability_id)
if ability_id > 0 and not ability_learned?(ability_id)
@abilities.push(ability_id)
end
end
#--------------------------------------------------------------------------
# * Determine if Finished Learning Ability
# state_id : state ID
#--------------------------------------------------------------------------
def ability_learned?(ability_id)
return @enabled_abilities.include?(ability_id)
end
#--------------------------------------------------------------------------
# * Determine if Finished Learning Ability
# state_id : state ID
#--------------------------------------------------------------------------
def enable_ability(index)
if @ap - $data_abilities[@abilities[index]].cost >= 0
@ap -= $data_abilities[@abilities[index]].cost
@enabled_abilities.push(@abilities[index])
end
end
#--------------------------------------------------------------------------
# * Determine if Finished Learning Ability
# state_id : state ID
#--------------------------------------------------------------------------
def disable_ability(index)
if ability_enabled?(index)
@ap += $data_abilities[@abilities[index]].cost
@enabled_abilities.delete(@abilities[index])
end
end
#--------------------------------------------------------------------------
# * Determine if the Ability is Enabled
# state_id : state ID
#--------------------------------------------------------------------------
def ability_enabled?(index)
return @enabled_abilities.include?($data_abilities[@abilities[index]].id)
end
#--------------------------------------------------------------------------
# * Applying Normal Attack Effects
# attacker : battler
#--------------------------------------------------------------------------
def attack_effect(attacker)
# Clear critical flag
self.critical = false
# First hit detection
hit_result = (rand(100) < attacker.hit)
# If hit occurs
if hit_result == true
# Calculate basic damage
atk = [attacker.atk - self.pdef / 2, 0].max
self.damage = atk * (20 + attacker.str) / 20
# Element correction
self.damage *= elements_correct(attacker.element_set)
self.damage /= 100
# If damage value is strictly positive
if self.damage > 0
# Critical correction
if rand(100) < 4 * attacker.dex / self.agi
self.damage *= 2
self.critical = true
end
# Guard correction
if self.guarding?
self.damage /= 2
end
end
# Dispersion
if self.damage.abs > 0
amp = [self.damage.abs * 15 / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# Second hit detection
eva = 8 * self.agi / attacker.dex + self.eva
hit = self.damage < 0 ? 100 : 100 - eva
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
end
# If hit occurs
if hit_result == true
# State Removed by Shock
remove_states_shock
for i in attacker.enabled_abilities
self.damage *= Integer($data_abilities[i].physicaldamage_rate / 100.0)
end
for i in @abilities
self.damage *= Integer((100 - $data_abilities[i].damage_reduction_rate) / 100.0)
end
for i in attacker.enabled_abilities
attacker.hp += Integer(($data_abilities[i].steal_hp_rate * self.damage) / 100.0)
attacker.sp += Integer(($data_abilities[i].steal_sp_rate * self.damage) / 100.0)
end
# Substract damage from HP
self.hp -= self.damage
# State change
@state_changed = false
states_plus(attacker.plus_state_set)
states_minus(attacker.minus_state_set)
# When missing
else
# Set damage to "Miss"
self.damage = "Verfehlt!"
# Clear critical flag
self.critical = false
end
# End Method
return true
end
#--------------------------------------------------------------------------
# * Apply Skill Effects
# user : the one using skills (battler)
# skill : skill
#--------------------------------------------------------------------------
def skill_effect(user, skill)
skill_index = user.find_skill_index(skill)
# Clear critical flag
self.critical = false
# If skill scope is for ally with 1 or more HP, and your own HP = 0,
# or skill scope is for ally with 0, and your own HP = 1 or more
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
# End Method
return false
end
# Clear effective flag
effective = false
# Set effective flag if common ID is effective
effective |= skill.common_event_id > 0
# First hit detection
hit = skill.hit
if skill.atk_f > 0
hit *= user.hit / 100
end
hit_result = (rand(100) < hit)
# Set effective flag if skill is uncertain
effective |= hit < 100
# If hit occurs
if hit_result == true
# Calculate power
power = (skill.power + user.atk * skill.atk_f / 100) * (1 + user.skill_level[skill_index] / 50)
if power > 0
power -= self.pdef * skill.pdef_f / 200
power -= self.mdef * skill.mdef_f / 200
power = [power, 0].max
end
# Calculate rate
rate = 20 + user.skill_level[skill_index] / 2
rate += (user.str * skill.str_f / 100)
rate += (user.dex * skill.dex_f / 100)
rate += (user.agi * skill.agi_f / 100)
rate += (user.int * skill.int_f / 100)
# Calculate basic damage
self.damage = power * rate / 20
# Element correction
self.damage *= elements_correct(skill.element_set)
self.damage /= 100
# If damage value is strictly positive
if self.damage > 0
# Guard correction
if self.guarding?
self.damage /= 2
end
end
# Dispersion
if skill.variance > 0 and self.damage.abs > 0
amp = [self.damage.abs * skill.variance / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# Second hit detection
eva = 8 * self.agi / user.dex + self.eva
hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
# Set effective flag if skill is uncertain
effective |= hit < 100
end
# If hit occurs
if hit_result == true
# If physical attack has power other than 0
if skill.power != 0 and skill.atk_f > 0
# State Removed by Shock
remove_states_shock
# Set to effective flag
effective = true
end
# Substract damage from HP
for i in user.abilities
self.damage *= $data_abilities[i].skilldamage_rate / 100.0
end
for i in @abilities
self.damage *= $data_abilities[i].damage_reduction_rate / 100.0
end
self.damage = Integer(self.damage)
last_hp = self.hp
self.hp -= self.damage
effective |= self.hp != last_hp
# Add 1% of the damage to skill exp
if user.is_a?(Game_Actor)
user.add_skill_exp(skill_index,self.damage / 100)
end
# State change
@state_changed = false
effective |= states_plus(skill.plus_state_set)
effective |= states_minus(skill.minus_state_set)
# If power is 0
if skill.power == 0
# Set damage to an empty string
self.damage = ""
# If state is unchanged
unless @state_changed
# Set damage to "Miss"
self.damage = "Verfehlt!"
end
end
# If miss occurs
else
# Set damage to "Miss"
self.damage = "Verfehlt!"
end
# If not in battle
unless $game_temp.in_battle
# Set damage to nil
self.damage = nil
end
# End Method
return effective
end
end



#==============================================================================
# ** 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
attr_reader :kills # enemy kills
attr_reader :skill_exp # skill EXP
attr_reader :skill_level # skill level
#--------------------------------------------------------------------------
# * Setup
# actor_id : actor ID
#--------------------------------------------------------------------------
def setup(actor_id)
actor = $data_actors[actor_id]
@actor_id = actor_id
@name = actor.name
@character_name = actor.character_name
@character_hue = actor.character_hue
@battler_name = actor.battler_name
@battler_hue = actor.battler_hue
@class_id = actor.class_id
@weapon_id = actor.weapon_id
@armor1_id = actor.armor1_id
@armor2_id = actor.armor2_id
@armor3_id = actor.armor3_id
@armor4_id = actor.armor4_id
@level = actor.initial_level
@exp_list = Array.new(101)
make_exp_list
@exp = @exp_list[@level]
@skills = []
@skill_exp_list = Array.new(101)
make_skill_exp_list
@skill_exp = []
@skill_level = []
@hp = maxhp
@sp = maxsp
@states = []
@states_turn = {}
@maxhp_plus = 0
@maxsp_plus = 0
@str_plus = 0
@dex_plus = 0
@agi_plus = 0
@int_plus = 0
@kills = 0
@ap = maxap
# Learn skill
for i in 1..@level
for j in $data_classes[@class_id].learnings
if j.level == i
learn_skill(j.skill_id)
end
end
end
# Update auto state
update_auto_state(nil, $data_armors[@armor1_id])
update_auto_state(nil, $data_armors[@armor2_id])
update_auto_state(nil, $data_armors[@armor3_id])
update_auto_state(nil, $data_armors[@armor4_id])
end
#--------------------------------------------------------------------------
# * Get Maximum HP
#--------------------------------------------------------------------------
def maxhp
n = [[base_maxhp + @maxhp_plus, 1].max, 999999].min
for i in @states
n *= $data_states[i].maxhp_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].maxhp_rate / 100.0
end
n = [[Integer(n), 1].max, 999999].min
return n
end
#--------------------------------------------------------------------------
# * Get Maximum SP
#--------------------------------------------------------------------------
def maxsp
n = [[base_maxsp + @maxsp_plus, 0].max, 9999].min
for i in @states
n *= $data_states[i].maxsp_rate / 100.0
end
for i in @enabled_abilities
n *= $data_abilities[i].maxsp_rate / 100.0
end
n = [[Integer(n), 0].max, 9999].min
return n
end
#--------------------------------------------------------------------------
# * Get Element Revision Value
# element_id : element ID
#--------------------------------------------------------------------------
def element_rate(element_id)
# Get values corresponding to element effectiveness
table = [0,200,150,100,50,0,-100]
result = table[$data_classes[@class_id].element_ranks[element_id]]
# If this element is protected by armor, then it's reduced by half
for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
armor = $data_armors[i]
if armor != nil and armor.guard_element_set.include?(element_id)
result /= 2
end
end
# If this element is protected by states, then it's reduced by half
for i in @states
if $data_states[i].guard_element_set.include?(element_id)
result /= 2
end
end
for i in @enabled_abilities
result *= $data_abilities[i].element_rate[element_id] / 100.0
end
# End Method
return Integer(result)
end
#--------------------------------------------------------------------------
# * Get Next Level EXP
#--------------------------------------------------------------------------
def next_exp
if @level < 99
return @exp_list[@level+1]
end
end
#--------------------------------------------------------------------------
# * Change EXP
# exp : new EXP
#--------------------------------------------------------------------------
def exp=(exp)
diff = exp - @exp
for i in @enabled_abilities
diff *= $data_abilities[i].exp_rate / 100.0
end
@exp = [[Integer(@exp + diff), 9999999].min, 0].max
# Level up
while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0
@level += 1
# Learn skill
for j in $data_classes[@class_id].learnings
if j.level == @level
learn_skill(j.skill_id)
end
end
end
# Level down
while @exp < @exp_list[@level]
@level -= 1
end
# Correction if exceeding current max HP and max SP
@hp = [@hp, self.maxhp].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# * Increases the Kills Counter by 1
#--------------------------------------------------------------------------
def add_kill
@kills += 1
end
#--------------------------------------------------------------------------
# * Calculate Skill EXP
#--------------------------------------------------------------------------
def make_skill_exp_list
actor = $data_actors[@actor_id]
@skill_exp_list[1] = 0
pow_i = 2.4 + actor.exp_inflation / 100.0
for i in 2..100
if i > 99
@skill_exp_list[i] = 0
else
n = actor.exp_basis * ((i + 3) ** pow_i) / (5 ** pow_i)
@skill_exp_list[i] = @skill_exp_list[i-1] + Integer(n)
end
end
end
#--------------------------------------------------------------------------
# * Get Until Next Level EXP
#--------------------------------------------------------------------------
def until_next_exp
return @level < 99 ? (@exp_list[@level+1] - @exp_list[@level]) : 0
end
#--------------------------------------------------------------------------
# * Learn Skill
# skill_id : skill ID
#--------------------------------------------------------------------------
def learn_skill(skill_id)
if skill_id > 0 and not skill_learn?(skill_id)
@skills.push(skill_id)
@skill_exp.push(0)
@skill_level.push(1)
end
end
#--------------------------------------------------------------------------
# * Get Next Skill Level EXP String
#--------------------------------------------------------------------------
def skill_next_exp_s
return @skill_exp_list[@level+1] > 0 ? @skill_exp_list[@level+1].to_s : "-------"
end
#--------------------------------------------------------------------------
# * Get Next Skill Level EXP
#--------------------------------------------------------------------------
def skill_next_exp(index)
if @skill_level[index] < 99
return @skill_exp_list[@skill_level[index]+1]
end
end
#--------------------------------------------------------------------------
# * Get Until Next Skill Level EXP
#--------------------------------------------------------------------------
def next_rest_skill_exp(index)
return @skill_level[index] < 99 ? (@skill_exp_list[@skill_level[index]+1] - @skill_exp_list[@skill_level[index]]) : 0
end
#--------------------------------------------------------------------------
# * Add Skill EXP
# index : skill index
# exp : new EXP
#--------------------------------------------------------------------------
def add_skill_exp(index, exp)
if @skill_level[index] < 99
@skill_exp[index] += exp
# Level up
while @skill_exp[index] >= @skill_exp_list[@skill_level[index]+1]
@skill_level[index] += 1
if @skill_level[index] == 99
return
end
end
end
end
#--------------------------------------------------------------------------
# * Change Skill Level
# level : new level
#--------------------------------------------------------------------------
def increase_skill_level(index)
# Check up and down limits
level = [[level, $data_actors[@actor_id].final_level].min, 1].max
# Change EXP
self.exp = @exp_list[level]
end
#--------------------------------------------------------------------------
# * Find Skill Index
#--------------------------------------------------------------------------
def find_skill_index(skill)
for i in 0..@skills.size
if @skills[i] == skill.id
return i
end
end
return 0
end
end


#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
# This class handles the party. It includes information on amount of gold
# and items. Refer to "$game_party" for the instance of this class.
#==============================================================================

class Game_Party
attr_reader :battle_count # number of battles
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
# Create actor array
@actors = []
# Initialize amount of gold and steps
@gold = 0
@steps = 0
# Initialize battle count
@battle_count = 0
# Create amount in possession hash for items, weapons, and armor
@items = {}
@weapons = {}
@armors = {}
end
#--------------------------------------------------------------------------
# * Gain Gold (or lose)
# n : amount of gold
#--------------------------------------------------------------------------
def gain_gold(n)
for actor in @actors
for i in actor.enabled_abilities
n *= $data_abilities[i].gold_rate / 100.0
end
end
@gold = [[@gold + Integer(n), 0].max, 9999999].min
end
#--------------------------------------------------------------------------
# * Add an Actor
# actor_id : actor ID
#--------------------------------------------------------------------------
def add_actor(actor_id)
# Get actor
actor = $game_actors[actor_id]
# Determine if the actor is in the party
if not @actors.include?(actor)
# Add actor
@actors.push(actor)
# Refresh player
$game_player.refresh
end
end
end


#==============================================================================
# ** Scene_Battle (part 1)
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# * Object Initialization
# spriteset : spriteset of the map to use as a background
#--------------------------------------------------------------------------
def initialize(spriteset)
@mapspriteset = spriteset
end
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
# Initialize each kind of temporary battle data
$game_temp.in_battle = true
$game_temp.battle_turn = 0
$game_temp.battle_event_flags.clear
$game_temp.battle_abort = false
$game_temp.battle_main_phase = false
$game_temp.forcing_battler = nil
# Initialize battle event interpreter
$game_system.battle_interpreter.setup(nil, 0)
# Prepare troop
@troop_id = $game_temp.battle_troop_id
$game_troop.setup(@troop_id)
# Make actor command window
s1 = $data_system.words.attack
s2 = $data_system.words.skill
s3 = $data_system.words.guard
s4 = $data_system.words.item
@actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])
@actor_command_window.y = 320
@actor_command_window.back_opacity = 160
@actor_command_window.active = false
@actor_command_window.visible = false
# Make other windows
@party_command_window = Window_PartyCommand.new
@help_window = Window_Help.new
@help_window.back_opacity = 160
@help_window.visible = false
@status_window = Window_BattleStatus.new
@message_window = Window_Message.new
# Make sprite set
@spriteset = Spriteset_Battle.new
# Initialize wait count
@wait_count = 0
# Execute transition
if $data_system.battle_transition == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$data_system.battle_transition)
end
# Start pre-battle phase
start_phase1
# Main loop
loop do
# Update game screen
Graphics.update
# Update input information
Input.update
# Frame update
update
# Abort loop if screen is changed
if $scene != self
break
end
end
# Refresh map
$game_map.refresh
# Prepare for transition
Graphics.freeze
# Dispose of windows
@actor_command_window.dispose
@party_command_window.dispose
@help_window.dispose
@status_window.dispose
@message_window.dispose
if @mapspriteset != nil
@mapspriteset.dispose
end
if @skill_window != nil
@skill_window.dispose
end
if @item_window != nil
@item_window.dispose
end
if @result_window != nil
@result_window.dispose
end
# Dispose of sprite set
@spriteset.dispose
# If switching to title screen
if $scene.is_a?(Scene_Title)
# Fade out screen
Graphics.transition
Graphics.freeze
end
# If switching from battle test to any screen other than game over screen
if $BTEST and not $scene.is_a?(Scene_Gameover)
$scene = nil
end
end
end


#==============================================================================
# ** Scene_Battle (part 3)
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# * Start Actor Command Phase
#--------------------------------------------------------------------------
def start_phase3
# Shift to phase 3
@phase = 3
# Set actor as unselectable
@actor_index = -1
@active_battler = nil
# Go to command input for next actor
phase3_next_actor
end
#--------------------------------------------------------------------------
# * Go to Command Input for Next Actor
#--------------------------------------------------------------------------
def phase3_next_actor
# Loop
begin
# Actor blink effect OFF
if @active_battler != nil
@active_battler.blink = false
end
# If last actor
item_index = $game_party.actors.size
if item_index > 3
item_index = 3
end
if @actor_index == item_index - 1
# Start main phase
start_phase4
return
end
# Advance actor index
@actor_index += 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
# Once more if actor refuses command input
end until @active_battler.inputable?
# Set up actor command window
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# * Go to Command Input of Previous Actor
#--------------------------------------------------------------------------
def phase3_prior_actor
# Loop
begin
# Actor blink effect OFF
if @active_battler != nil
@active_battler.blink = false
end
# If first actor
if @actor_index == 0
# Start party command phase
start_phase2
return
end
# Return to actor index
@actor_index -= 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
# Once more if actor refuses command input
end until @active_battler.inputable?
# Set up actor command window
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# * Actor Command Window Setup
#--------------------------------------------------------------------------
def phase3_setup_command_window
# Disable party command window
@party_command_window.active = false
@party_command_window.visible = false
# Enable actor command window
@actor_command_window.active = true
@actor_command_window.visible = true
# Set actor command window position
@actor_command_window.x = 0
# Set index to 0
@actor_command_window.index = 0
end
#--------------------------------------------------------------------------
# * Frame Update (actor command phase)
#--------------------------------------------------------------------------
def update_phase3
# If enemy arrow is enabled
if @enemy_arrow != nil
update_phase3_enemy_select
# If actor arrow is enabled
elsif @actor_arrow != nil
update_phase3_actor_select
# If skill window is enabled
elsif @skill_window != nil
update_phase3_skill_select
# If item window is enabled
elsif @item_window != nil
update_phase3_item_select
# If actor command window is enabled
elsif @actor_command_window.active
update_phase3_basic_command
end
end
#--------------------------------------------------------------------------
# * Frame Update (actor command phase : basic command)
#--------------------------------------------------------------------------
def update_phase3_basic_command
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# Go to command input for previous actor
phase3_prior_actor
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Branch by actor command window cursor position
case @actor_command_window.index
when 0 # attack
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 0
# Start enemy selection
start_enemy_select
when 1 # skill
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.kind = 1
# Start skill selection
start_skill_select
when 2 # guard
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 1
# Go to command input for next actor
phase3_next_actor
when 3 # item
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.kind = 2
# Start item selection
start_item_select
end
return
end
end
#--------------------------------------------------------------------------
# * Frame Update (actor command phase : skill selection)
#--------------------------------------------------------------------------
def update_phase3_skill_select
# Make skill window visible
@skill_window.visible = true
# Update skill window
@skill_window.update
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# End skill selection
end_skill_select
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Get currently selected data on the skill window
@skill = @skill_window.skill
# If it can't be used
if @skill == nil or not @active_battler.skill_can_use?(@skill.id)
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.skill_id = @skill.id
# Make skill window invisible
@skill_window.visible = false
# If effect scope is single enemy
if @skill.scope == 1
# Start enemy selection
start_enemy_select
# If effect scope is single ally
elsif @skill.scope == 3 or @skill.scope == 5
# Start actor selection
start_actor_select
# If effect scope is not single
else
# End skill selection
end_skill_select
# Go to command input for next actor
phase3_next_actor
end
return
end
end
#--------------------------------------------------------------------------
# * Frame Update (actor command phase : item selection)
#--------------------------------------------------------------------------
def update_phase3_item_select
# Make item window visible
@item_window.visible = true
# Update item window
@item_window.update
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# End item selection
end_item_select
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Get currently selected data on the item window
@item = @item_window.item
# If it can't be used
unless $game_party.item_can_use?(@item.id)
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.item_id = @item.id
# Make item window invisible
@item_window.visible = false
# If effect scope is single enemy
if @item.scope == 1
# Start enemy selection
start_enemy_select
# If effect scope is single ally
elsif @item.scope == 3 or @item.scope == 5
# Start actor selection
start_actor_select
# If effect scope is not single
else
# End item selection
end_item_select
# Go to command input for next actor
phase3_next_actor
end
return
end
end
#--------------------------------------------------------------------------
# * Frame Updat (actor command phase : enemy selection)
#--------------------------------------------------------------------------
def update_phase3_enemy_select
# Update enemy arrow
@enemy_arrow.update
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# End enemy selection
end_enemy_select
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.target_index = @enemy_arrow.index
# End enemy selection
end_enemy_select
# If skill window is showing
if @skill_window != nil
# End skill selection
end_skill_select
end
# If item window is showing
if @item_window != nil
# End item selection
end_item_select
end
# Go to command input for next actor
phase3_next_actor
end
end
#--------------------------------------------------------------------------
# * Frame Update (actor command phase : actor selection)
#--------------------------------------------------------------------------
def update_phase3_actor_select
# Update actor arrow
@actor_arrow.update
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# End actor selection
end_actor_select
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Set action
@active_battler.current_action.target_index = @actor_arrow.index
# End actor selection
end_actor_select
# If skill window is showing
if @skill_window != nil
# End skill selection
end_skill_select
end
# If item window is showing
if @item_window != nil
# End item selection
end_item_select
end
# Go to command input for next actor
phase3_next_actor
end
end
#--------------------------------------------------------------------------
# * Start Enemy Selection
#--------------------------------------------------------------------------
def start_enemy_select
# Make enemy arrow
@enemy_arrow = Arrow_Enemy.new(@spriteset.viewport1)
# Associate help window
@enemy_arrow.help_window = @help_window
# Disable actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
end
#--------------------------------------------------------------------------
# * End Enemy Selection
#--------------------------------------------------------------------------
def end_enemy_select
# Dispose of enemy arrow
@enemy_arrow.dispose
@enemy_arrow = nil
# If command is [fight]
if @actor_command_window.index == 0
# Enable actor command window
@actor_command_window.active = true
@actor_command_window.visible = true
# Hide help window
@help_window.visible = false
end
end
#--------------------------------------------------------------------------
# * Start Actor Selection
#--------------------------------------------------------------------------
def start_actor_select
# Make actor arrow
@actor_arrow = Arrow_Actor.new(@spriteset.viewport2)
@actor_arrow.index = @actor_index
# Associate help window
@actor_arrow.help_window = @help_window
# Disable actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
end
#--------------------------------------------------------------------------
# * End Actor Selection
#--------------------------------------------------------------------------
def end_actor_select
# Dispose of actor arrow
@actor_arrow.dispose
@actor_arrow = nil
end
#--------------------------------------------------------------------------
# * Start Skill Selection
#--------------------------------------------------------------------------
def start_skill_select
# Make skill window
@skill_window = Window_Skill.new(@active_battler)
# Associate help window
@skill_window.help_window = @help_window
# Disable actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
end
#--------------------------------------------------------------------------
# * End Skill Selection
#--------------------------------------------------------------------------
def end_skill_select
# Dispose of skill window
@skill_window.dispose
@skill_window = nil
# Hide help window
@help_window.visible = false
# Enable actor command window
@actor_command_window.active = true
@actor_command_window.visible = true
end
#--------------------------------------------------------------------------
# * Start Item Selection
#--------------------------------------------------------------------------
def start_item_select
# Make item window
@item_window = Window_Item.new
# Associate help window
@item_window.help_window = @help_window
# Disable actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
end
#--------------------------------------------------------------------------
# * End Item Selection
#--------------------------------------------------------------------------
def end_item_select
# Dispose of item window
@item_window.dispose
@item_window = nil
# Hide help window
@help_window.visible = false
# Enable actor command window
@actor_command_window.active = true
@actor_command_window.visible = true
end
end


Wenn sich jemand wirklich die Arbeit macht, diese Skripte zu vergleichen und sogar den Fehler zu finden (eventuell braucht man noch mehr meiner Skripte), wird dieser natürlich mit einem Creditseintrag belohnt. Das SDK wird nicht verwendet. Und nochmal zur Erinnerung: Alle Skripte sind auch in der Demo eingebaut, dort funktioniert es einwandfrei!

[Kelven]

Das Problem kommt daher, dass in Game_Actor auf skills nicht mehr von außen zugegriffen werden kann. In der Standard-Klasse steht auch ein attr_reader :skills. Und das ursprüngliche Problem könnte damit zusammenhängen, dass find_skill_index vielleicht nur in Game_Actor, aber nicht in Game_Enemy definiert ist. Game_Battler ist ja die Superklasse der beiden.

[Expresseon]

Klingt logisch, denn als Game_Enemy wird das Standardskript des Makers verwendet, Game_Actor hingegen stammt aus der Demo.

[-KD-]

Jetzt wird die ganze Sache doch verständlicher. Tjoar, Kelven hat eigentlich schon alles gesagt. Reader-Methode skills fehlt, find_skill_index ist nur in Game_Actor definiert, die Methode wird aber laut Fehlermeldung auch für Game_Enemy aufgerufen.


class Game_Enemy
def find_skill_index(skill)
$data_enemies[@enemy_id].actions.find {|action|
action.kind==1 and action.skill_id == skill.id
} || 0
end
end
Wenn du den Code einfügst dürfte es funktionieren, da dann find_skill_index auch für Game_Enemy definiert ist.

[Expresseon]

Jo danke erstmal -KD-, das hat wirklich geholfen. Leider sind anscheinend noch andere Methoden undefiniert, z.B. im Game_Battler dieses mal skill_level.
In der Demo müssen diese doch irgendwo definiert sein, ich werde mal nachsehen.

[-KD-]

Naja, skill_level, skill_exp sind für gewöhnlich auch nur für den Actor interessant, da nur er seine Skills mit der Zeit aufleveln kann. Dein Script hingegen scheint sowas auch für Enemies zu verwenden, was an sich irgendwie unlogisch scheint.


class Game_Battler
attr_reader :kills # enemy kills
attr_reader :skill_exp # skill EXP
attr_reader :skill_level # skill level
alias skill_level_initialize initialize
def initialize(*p)
skill_level_initialize(*p)
@kills, @skill_exp, @skill_level = 0, [], []
end
end

[Expresseon]

Ja das kommt mir auch seltsam vor, da ja nur man selbst seine Skills aufleveln kann. Ich habe die beiden von dir geposteten Klassen in ein neues Skript gepackt, *seufz*, NoMethodError von: []. Hast du nicht ICQ, ich würde dir gerne mal mein Projekt zeigen, vielleicht kannst du mir dann besser helfen. Danke bis jetzt. ;)