Skriptproblem

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?

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. :(

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.

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.

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.

Zitat:

---

Zitat von P-Games

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

@ 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...

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

Code:

---

  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.

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

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.

Code:

---

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

---

Möglich wäre auch:

Code:

---

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.

@-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:

Zitat:

---

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.

-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?

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.

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.

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.

Zitat:

---

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 ^^°

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?

Code:

---

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

---

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.

Code:

---

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

---

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.

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.

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

---

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.

Code:

---

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...

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*

Zitat:

---

Zitat von -KD-

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?

Zitat:

---

Zitat von -KD-

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

---

Gut, bedenke aber:

Zitat:

---

Zitat von P-Games

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

---

Code:

---

#==============================================================================
# ** 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

---

Code:

---

#==============================================================================
# ** 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

---

Code:

---

#==============================================================================
# ** 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

---

Code:

---

#==============================================================================
# ** 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

---

Code:

---

#==============================================================================
# ** 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!

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.

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

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.

Code:

---

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.

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.

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.

Code:

---

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

---

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. ;)