Ruby Quellcode

###############################################################################
# Diese Klasse regelt die Charakterauswahl.
# Sollte überflüssig werden wenn die Technik-Indormation in ein geeignetes Menü
# eingebunden wird.
###############################################################################
 
class Scene_IL_Skillinfo_CS
  #Klasse enthält die definierten Übersetzungen:  
  include(IL_Tech_Info_Scene)
 
  def initialize(index = 0, from_menu = 0)
    #Setze Index fest und korrigiere ihn wenn er außerhalb der Gruppengröße liegt
    @actor_index = $game_party.actors.size == 0 ? -1 : (index % $game_party.actors.size)
    #Speichere vorhergegangene Scene: 0 = Map, 1 = Menü
    @from_menu = from_menu
  end
 
  def main
    #setze Hintergrund
    @background = Sprite.new
    bitmap = RPG::Cache.windowskin($game_system.windowskin_name)
    @background.bitmap = Bitmap.new(64,64)
    @background.bitmap.blt(0, 0, bitmap, Rect.new(0,0,64,64))
    @background.zoom_y = 7.5
    @background.zoom_x = 10.0
    @background.opacity = 128
    @background.z = 11
    #Erstelle Charakterfenster
    @character_window = Window_MenuStatus.new
    @character_window.x = 80
    @character_window.active = true
    #Setze das Charakterfenster auf den mitgegebenen Index:
    @character_window.index = @actor_index
 
    #Übergang zur Hauptschleife:
    Graphics.transition
    # 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
    # Prepare for transition
    Graphics.freeze
 
    #Zerstöre die in der Scene benutzten Fenster:
    @background.bitmap.dispose
    @background.dispose
    @character_window.dispose
  end  
 
  def update
    #aktualisiere das Auswahlfenster
    @character_window.update
    #Überprüfe ob "Abbrechen" gedrückt wurde:
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      if @from_menu == 0
        $scene = Scene_Map.new
      else  
        $scene = Scene_Menu.new(IL_MENUE_INDEX)
      end  
      return
    end
    # Überprüfe ob "Aktion" gedrückt wurde:
    if Input.trigger?(Input::C)
      case @character_window.index
      #Überprüfe ob der Index innerhalb der Gruppengröße liegt (nicht -1)
      when 0...$game_party.actors.size
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_IL_Skillinfo.new(@character_window.index, 2 + @from_menu % 2)
      else
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      return
    end
  end
end  
 
 
###############################################################################
# Die folgende Klasse enthält das Auswahlfenster für alle Techniken, die der
# entspr. Charakter beherrscht oder beherrschen wird.
# Das Fenster für die Technikbeschreibung ist dabei ebenfalls enthalten:
###############################################################################
 
class Window_Skillinfo_Selection < Window_Selectable
 
  #Enthält die definierten Übersetzungen:
  include(IL_Tech_Info_Scene)
 
  #Fenster wird erstellt
  def initialize(actor_id)
    super(0,128,640, 288)
    @column_max = 2
    @index = -1
 
    #Hilfsfenster für Technikbeschreibung wird erstellt
    @skill_description_window = Window_Base.new(0,64,640,64)
    @skill_description_window.contents = Bitmap.new(608, 32)
    @skill_description_window.z = 5000
 
    #Fülle die Fenster mit Inhalt:
    refresh(actor_id)
    self.active = true
  end  
 
  def refresh(actor_id)
    #"Alter Index" wird zurückgesetzt
    @old_index = -1
    #Fensterinhalt des Beschreibungsfensters wird geleert
    @skill_description_window.contents.clear
    # aktiver Charakter wird gesetzt:
    @actor_id = actor_id
    actor = $game_party.actors[@actor_id]
    #Wenn im Hauptfenster eine Bildfläche existiert entferne sie
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    #Bestimme Datenmenge...
    @data = []
    # ...für bereits gelernte Skills:
    for i in 0...actor.skills.size
      skill = $data_skills[actor.skills[i]]
      if skill != nil
        @data.push(skill)
      end
    end
    # ...für zukünftige Skills:
    for i in $data_classes[actor.class_id].learnings
      if i.level > actor.level and not actor.skill_learn?(i.skill_id)
        @data.push(i.level)
      end
    end
    # Sichere Datenmenge:
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
    # Setze Index:
    @index = @item_max == 0 ? -1 : 0
    # Update das Cursorfenster:
    update_cursor_rect
  end
 
  def update
    #aktualisiere Haupt- und Beschreibungsfenster, aktualisiere Index
    super
    if self.active and @skill_description_window != nil and @old_index != @index 
      update_description
      @old_index = @index
    end
  end
 
  #Zerstöre Haupt- und Beschreibungsfenster:
  def dispose
    @skill_description_window.dispose
    super
  end  
 
  # Präsentiere die aktuell gewählte Technik:
  def skill
    return @data[self.index]
  end
 
 
  # Male die Fähigkeiten ins Auswahlfenster:
  def draw_item(index)
    skill = @data[index]
    # Wenn ein gelernter Skill:
    if skill.is_a?(RPG::Skill)
      self.contents.font.color = normal_color
      x = 4 + index % 2 * (288 + 32)
      y = index / 2 * 32
      rect = Rect.new(x, y, self.width / @column_max - 32, 32)
      self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
      bitmap = RPG::Cache.icon(skill.icon_name)
      opacity = 255
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
      self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
    # ein noch nicht gelernter Skill:  
    elsif skill.is_a?(Numeric)
      self.contents.font.color = disabled_color
      x = 4 + index % 2 * (288 + 32)
      y = index / 2 * 32
      rect = Rect.new(x, y, self.width / @column_max - 32, 32)
#      bitmap = RPG::Cache.icon(DISABLED_ICON_NAME)
      opacity = 128
#      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      self.contents.draw_text(x + 28, y, 204, 32, "????????????", 0)
    end  
  end
 
#-Update des Hilfefensters von Window_Selectable, welches hier jedoch nicht verwendet wird.
  def update_help
  end
 
#-Alternatives Hilfefenster-Update
  def update_description
    #leere Fensterinhalt:
    @skill_description_window.contents.clear
    @skill_description_window.contents.font.color = normal_color
    # Male neue Beschreibung:
    if @data[self.index].is_a?(RPG::Skill)
      @skill_description_window.contents.draw_text(0,0,608,32,@data[self.index].description,0)
    elsif @data[self.index].is_a?(Numeric)
      @skill_description_window.contents.draw_text(0,0,608,32,IL_PRE_LEVEL + " " + IL_LEVEL + " "+@data[self.index].to_s + " " + IL_POST_LEVEL,0)
    else
      @skill_description_window.contents.draw_text(0,0,608,32,"",0)
    end  
  end
end
 
###############################################################################
# Die folgende Klasse enthält das Fensterset, welches bei der Wahl einer
# Technik als Info-Fenster gezeigt wird:
###############################################################################
 
class Windowset_Skillinfo
 
  # Enthält die definierten Übersetzungen:
  include(IL_Tech_Info_Scene)
 
  def initialize
    #Erstelle Fensterset
    @window1 = Window_Base.new(0,128,390,36)
    @window2 = Window_Base.new(390,128,250,36)
    @window3 = Window_Base.new(0,164,390,60)
    @window4 = Window_Base.new(390,164,250,60)
    @window5 = Window_Base.new(0,224,640,60)
    @window6 = Window_Base.new(0,284,640,60)
    @window7 = Window_Base.new(0,344,640,136)
    #Erstelle Sprite, auf dem die Werte gezeichnet werden:
    @sprite = Sprite.new
    @sprite.x = 16
    @sprite.y = 134
    @sprite.z = 5000
    @sprite.bitmap = Bitmap.new(608, 346)    
  end  
 
  # Erweiterte Textfarben: Entnommen aus Window_Base
  def text_color(n)
    case n
    when 1
      return Color.new(128, 128, 255, 255)
    when 2
      return Color.new(255, 128, 128, 255)
    when 3
      return Color.new(128, 255, 128, 255)
    when 4
      return Color.new(128, 255, 255, 255)
    when 5
      return Color.new(255, 128, 255, 255)
    when 6
      return Color.new(255, 255, 128, 255)
    when 7
      return Color.new(192, 192, 192, 255)
    else
      return Color.new(255, 255, 255, 255)
    end
  end
 
  # Regle Richtbarkeit sämtlicher Fenster und des Sprites:
  def visible(invis)
    @window1.visible = invis
    @window2.visible = invis
    @window3.visible = invis
    @window4.visible = invis
    @window5.visible = invis
    @window6.visible = invis
    @window7.visible = invis
    @sprite.visible = invis
  end
 
  # Zerstöre alle Fenster, Spriteinhalt und den Sprite
  def dispose
    @window1.dispose
    @window1 = nil
    @window2.dispose
    @window2 = nil
    @window3.dispose
    @window3 = nil
    @window4.dispose
    @window4 = nil
    @window5.dispose
    @window5 = nil
    @window6.dispose
    @window6 = nil
    @window7.dispose
    @window7 = nil
    @sprite.bitmap.dispose
    @sprite.bitmap = nil
    @sprite.dispose
    @sprite = nil
  end  
 
  # Aktualisiere den Fensterinhalt:
  def refresh(skill)    
    #leere die Bildfläche:
    @sprite.bitmap.clear
    @sprite.bitmap.font.size = 24
    @sprite.bitmap.font.color = text_color(0)
 
    #SP-Kosten:
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(390,0,150,24, IL_SP_COST, 0)
    @sprite.bitmap.font.bold = false
    @sprite.bitmap.draw_text(540,0,68,24,skill.sp_cost.to_s, 2)
 
    #Ziel:
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(0,0,140,24,IL_TARGET, 0)
    @sprite.bitmap.font.bold = false
    #Wähle den passenden Begriff:
    case skill.scope
    when 0
      scope = IL_SCOPE0
    when 1  
      scope = IL_SCOPE1
    when 2
      scope = IL_SCOPE2
    when 3
      scope = IL_SCOPE3
    when 4
      scope = IL_SCOPE4
    when 5
      scope = IL_SCOPE5
    when 6
      scope = IL_SCOPE6
    when 7
      scope = IL_SCOPE7
    end  
    @sprite.bitmap.draw_text(140,0,218,24,scope, 2)
 
    #Elemente
    elements = ""
    element_counter = 0
    #Gehe die Elemente durch und addiere sie zum String:
    skill.element_set.each do |i|
      # Werden es mehr als 3 Elemente nehme die "Massenelement"-Übersetzung:
      if element_counter == 3
        elements = IL_MASS_ELEMENT
        break
      else   
        #sonst:
        elements = elements + " / " if element_counter > 0
        elements = elements + $data_system.elements[i]
        element_counter += 1
      end
    end
    #Sind keine Elemente vorhanden nehme die "Neutral"-Übersetzung:
    elements = IL_NEUTRAL if element_counter == 0
    #Zeichne die Auswahl:
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(0, 36,100,24, IL_ELEMENT, 0)
    @sprite.bitmap.font.bold = false
    @sprite.bitmap.draw_text(90, 36,268,24, elements, 2)
 
    #Grundschaden und Abweichung
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(390,36,150,24,IL_POWER, 0)
    @sprite.bitmap.font.bold = false
    #Wenn der Grundschaden kleiner als 0 ist kennzeichne den Zauber als Heilzauber:
    healing_spell = (skill.power < 0)
    @sprite.bitmap.draw_text(540,36,68,24, skill.power.abs.to_s, 2)
    #Schreibe Varianz
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(390, 60, 150, 24, IL_VARIANCE,0)
    @sprite.bitmap.font.bold = false
    @sprite.bitmap.draw_text(540, 60, 68, 24, skill.variance.to_s + "\%",2)
 
    #Trefferchance
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(0, 60, 105, 24, IL_HIT,0)
    #Prüfe die Textlänge von Hit + EVA -String zu groß ist:
    textsize1 = @sprite.bitmap.text_size(skill.hit.to_s + "\%").width 
    textsize2 = @sprite.bitmap.text_size(" - " + skill.eva_f.to_s + "\% "+ IL_EVA).width
    textsize1 += textsize2
    #verkleinere beide Strings wenn nötig:
    if textsize1 > 250
      textsize2 = textsize2 * 250 / textsize1
    end
    #Zeichne Trefferchance
    @sprite.bitmap.font.bold = false
    #Wenn EVA gezeichnet werden soll:
    if skill.eva_f > 0 
      @sprite.bitmap.draw_text(100, 60, 250 - textsize2, 24, skill.hit.to_s + "\%",2)
      #Ausweichrate: Wenn Heilzauber: neutrale Färbung, sonst rote
      @sprite.bitmap.font.color = healing_spell ? text_color(0) : text_color(2)
      @sprite.bitmap.draw_text(355 - textsize2, 60, textsize2 + 3, 24, "- " + skill.eva_f.to_s + "\% "+ IL_EVA,2)
      @sprite.bitmap.font.color = text_color(0)
    else
    #Wenn EVA nicht gezeichnet wird (da 0):  
      @sprite.bitmap.draw_text(100, 60, 258, 24, skill.hit.to_s + "\%",2)
    end  
 
    #Einflüsse
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(0, 96,144,24, IL_INFLUENCES, 0)
    @sprite.bitmap.font.bold = false
    #Setze Positionszähler auf Startwert:
    position = 1
    #Grüne Farbe für positive Boni:
    @sprite.bitmap.font.color = text_color(3)
    #Zeichne Bonus, wenn > 0
    if skill.atk_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.atk + ": " + skill.atk_f.to_s + "\%", 1)
      position += 1
    end  
    if skill.str_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.str + ": " + skill.str_f.to_s + "\%", 1)
      position += 1
    end  
    if skill.dex_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.dex + ": " + skill.dex_f.to_s + "\%", 1)
      position += 1
    end  
    if skill.agi_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.agi + ": " + skill.agi_f.to_s + "\%", 1)
      position += 1
    end  
    if skill.int_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.int + ": " + skill.int_f.to_s + "\%", 1)
      position += 1
    end  
 
    #Schwächende Boni: Wenn Heilzauber: neutrale Färbung, sonst rote
    @sprite.bitmap.font.color = healing_spell ? text_color(0) : text_color(2)
 
    if skill.pdef_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.pdef + ": " + skill.pdef_f.to_s + "\%", 1)
      position += 1
    end  
    if skill.mdef_f > 0
      @sprite.bitmap.draw_text( 144 * (position % 4) , 96 + (position / 4)* 24, 144, 24,
        $data_system.words.mdef + ": " + skill.mdef_f.to_s + "\%", 1) 
    end  
    @sprite.bitmap.font.color = text_color(0)
 
    #Statusveränderungen:
    @sprite.bitmap.font.bold = true
    @sprite.bitmap.draw_text(0,156,144,24,IL_STATES, 0)
    #Setze Positionszähler auf Startwert:
    position = 1
    #Gehe die Statuswerte durch und überprüfe auf Veränderung:
    for i in 1...$data_states.size
      #fügt Effekt hinzu?
      if skill.plus_state_set.include?(i)
        @sprite.bitmap.font.size = 24
        @sprite.bitmap.font.bold = true
        #Male Hintergrund von "+":
        @sprite.bitmap.font.color = Color.new(0,0,0,255)
        @sprite.bitmap.draw_text( -7 + 144 * (position % 4),155 + (position / 4) * 24,24,24,"+", 1)
        @sprite.bitmap.draw_text( -7 + 144 * (position % 4),158 + (position / 4) * 24,24,24,"+", 1)
        @sprite.bitmap.draw_text( -4 + 144 * (position % 4),155 + (position / 4) * 24,24,24,"+", 1)
        @sprite.bitmap.draw_text( -4 + 144 * (position % 4),158 + (position / 4) * 24,24,24,"+", 1)
        #male farbigen Vordergrund von "+":
        @sprite.bitmap.font.color = text_color(3)
        @sprite.bitmap.draw_text( -6 + 144 * (position % 4),156 + (position / 4) * 24,24,24,"+", 1)
        @sprite.bitmap.font.size = 24
        @sprite.bitmap.font.bold = false
        @sprite.bitmap.font.color = text_color(0)
        #Male Statusname
        @sprite.bitmap.draw_text( 18 + 144 * (position % 4) ,156 + (position / 4)* 24,120,24,$data_states[i].name, 0)
        #erhöhe Positionszähler:
        position += 1
      # entfernt Effekt?  
      elsif skill.minus_state_set.include?(i)
        @sprite.bitmap.font.size = 24
        @sprite.bitmap.font.bold = true
        #Male Hintergrund von "-":
        @sprite.bitmap.font.color = Color.new(0,0,0,255)
        @sprite.bitmap.draw_text( -7 + 144 * (position % 4),155 + (position / 4) * 24,24,24,"-", 1)
        @sprite.bitmap.draw_text( -7 + 144 * (position % 4),158 + (position / 4) * 24,24,24,"-", 1)
        @sprite.bitmap.draw_text( -4 + 144 * (position % 4),155 + (position / 4) * 24,24,24,"-", 1)
        @sprite.bitmap.draw_text( -4 + 144 * (position % 4),158 + (position / 4) * 24,24,24,"-", 1)
        #male farbigen Vordergrund von "-":
        @sprite.bitmap.font.color = text_color(2)
        @sprite.bitmap.draw_text( -6 + 144 * (position % 4),156 + (position / 4) * 24,24,24,"-", 1)
        @sprite.bitmap.font.size = 24
        @sprite.bitmap.font.bold = false
        @sprite.bitmap.font.color = text_color(0)
        #Male Statusname
        @sprite.bitmap.draw_text( 18 + 144 * (position % 4) ,156 + (position / 4)* 24,120,24,$data_states[i].name, 0)
        #erhöhe Positionszähler:
        position += 1
      end
      # Wenn Positionszähler 8 erreicht hat Breche aus der Schleife:
      break if position == 8
    end
    @sprite.bitmap.font.bold = false
 
    #Kommentare: Wenn definiert, füge sie hinzu:
    unless COMMENTS[skill.id] == nil
      COMMENTS[skill.id].each_with_index do |i, index|
        @sprite.bitmap.draw_text(0, 218 + index * 24, 640, 24,i, 0)
      end
    end  
  end
 
end
 
###############################################################################
# Folgende Klasse steuert das Info-Fensterset und das Technik-Auswahlfenster.
# Sie enthält zudem alle weiteren von nicht aufgezählten Fenster.
###############################################################################
 
class Scene_IL_Skillinfo
 
  # Enthält die definierten Übersetzungen:
  include(IL_Tech_Info_Scene)
 
  def initialize(actor_id = 0, from_scene = 0)
    #Wenn die Gruppengröße = 0 sein sollte kehre sofort zur vorherigen Scene zurück:
    if $game_party.actors.size == 0
      $scene = from_menue = 1 ? Scene_Menu.new : Scene_Map.new
    end
    #Setze Actor-Index:
    @actor_id = actor_id % $game_party.actors.size
    #Sichere die vorhergegangene Scene: 0 = Map, 1 = Menü, 2 = Actor-Auswahl (Map)
    # 3 = Actor-Auswahl (Menü)
    @from_scene = from_scene
  end  
 
  def main
    #Erstelle das obere rechte Überschriftfenster:
    @headline2_window = Window_Base.new(320-80,0,320+80,64)
    @headline2_window.contents = Bitmap.new(288+80, 32)
    @headline2_window.contents.draw_text(0,0,288+80,32,IL_UPPER_RIGHT_WINDOW_TEXT,1)
    #Erstelle das obere, linke Überschriftfenster:
    @headline1_window = Window_Base.new(0,0,240,64)
    @headline1_window.contents = Bitmap.new(208, 32)
    @headline1_window.contents.draw_text(0,0,128,32,$game_party.actors[@actor_id].name,1)
    @headline1_window.contents.draw_text(120,0,75,32,IL_LEVEL + " " + $game_party.actors[@actor_id].level.to_s,2)
    #Erstelle das Technik-Auswahlfenster:
    @skill_select_window = Window_Skillinfo_Selection.new(@actor_id)    
    #Erstelle das Technikinfo-Fensterset
    @skill_info_window = Windowset_Skillinfo.new
    @skill_info_window.visible(false) 
    #Erstelle das untere Informationsfenster:
    @bottom_line_window = Window_Base.new(0,416,640,64)
    @bottom_line_window.contents = Bitmap.new(608, 32)
    @bottom_line_window.contents.draw_text(0,0,608,32,IL_BOTTOM_WINDOW_TEXT,1)
 
    #Übergang zur Hauptschleife:
    Graphics.transition
    # 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
    # Prepare for transition
    Graphics.freeze
 
    # Zerstöre die oben erstellten Fenster:
    @bottom_line_window.dispose
    @skill_info_window.dispose
    @skill_select_window.dispose
    @headline1_window.dispose
    @headline2_window.dispose
  end
 
 
  def update
    #Aktualisiere das Auswahlfenster:
    @skill_select_window.update
    #Wenn "Abbruch" gedrückt wurde:
    if Input.trigger?(Input::B)
      #Wenn sich der Spieler im Auswahlfenster befindet breche die Scene ab:
      if @skill_select_window.active
        # Spiele Abbruch-Sound
        $game_system.se_play($data_system.cancel_se)
        # Kehre zur vorhergegangenen Scene zurück
        case @from_scene
        when 0
          $scene = Scene_Map.new
        when 1
          $scene = Scene_Menu.new(IL_MENUE_INDEX)
        when 2
          $scene = Scene_IL_Skillinfo_CS.new(@actor_id, 0)
        when 3
          $scene = Scene_IL_Skillinfo_CS.new(@actor_id, 1)
        end  
        return
      else
      #Sonst beende das Informationsfenster und kehre zur Auswahl zurück:
        # Spiele Abbruch-Sound
        $game_system.se_play($data_system.cancel_se)
        # Ändere Fenstersichtbarkeit
        @skill_select_window.visible = true
        @skill_select_window.active = true
        @skill_info_window.visible(false)
        @bottom_line_window.visible = true
        # Schreibe die erste Überschrift wieder auf den Actor um:
        @headline1_window.contents.clear
        @headline1_window.contents.draw_text(0,0,120,32,$game_party.actors[@actor_id].name,0)
        @headline1_window.contents.draw_text(120,0,88,32,IL_LEVEL + " " + $game_party.actors[@actor_id].level.to_s,2)
      end  
    end
    #Wenn "Aktion" gedrückt wurde:
    if Input.trigger?(Input::C)
      #Wenn sich der Spieler im Auswahlfenster befindet breche ab:
      if @skill_select_window.active
        # Prüfe ob der ausgewählte Skill gültig ist, breche ab wenn nicht:
        unless @skill_select_window.skill.is_a?(RPG::Skill)
          #Wenn nein spiele Buzzersound und kehre zurück
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        #Sonst öffne das Infofenster
        # Spiele Auswahlsound
        $game_system.se_play($data_system.decision_se)
        Graphics.freeze
        #schreibe das linke Überschriftfenster auf den Skill um:        
        @headline1_window.contents.clear
        bitmap = RPG::Cache.icon(@skill_select_window.skill.icon_name)
        @headline1_window.contents.blt(4, 4, bitmap, Rect.new(0, 0, 24, 24), 255)
        @headline1_window.contents.draw_text(32, 0, 200, 32, @skill_select_window.skill.name, 0)
        # aktualisiere das Infofenster
        @skill_info_window.refresh(@skill_select_window.skill)
        # Ändere Fenstersichtbarkeit
        @skill_select_window.visible = false
        @skill_select_window.active = false
        @skill_info_window.visible(true)
        @bottom_line_window.visible = false
        Graphics.transition
      else
      #Befindet sich der Spieler im Infofenster:
        # Spiele Abbruch-Sound
        $game_system.se_play($data_system.cancel_se)
        # Ändere Fenstersichtbarkeit
        @skill_select_window.visible = true
        @skill_select_window.active = true
        @skill_info_window.visible(false)
        @bottom_line_window.visible = true
        # Schreibe die erste Überschrift wieder auf den Actor um:
        @headline1_window.contents.clear
        @headline1_window.contents.draw_text(0,0,128,32,$game_party.actors[@actor_id].name,1)
        @headline1_window.contents.draw_text(120,0,75,32,IL_LEVEL + " " + $game_party.actors[@actor_id].level.to_s,2)
      end  
    end
    # Wenn "W"(R) gedrückt wurde
    if Input.trigger?(Input::R)
      #Wechsle den aktuellen Actor, sofern das Auswahlfenster aktiv und die
      #Gruppengröße größer als 1 ist:
      return unless @skill_select_window.active and $game_party.actors.size >= 2
      # Spiele Cursorsound
      $game_system.se_play($data_system.cursor_se)
      @actor_id += 1
      @actor_id %= $game_party.actors.size
      # Update alle nötigen Fenster:
      Graphics.freeze
      refresh_after_actor_changed
      Graphics.transition
      return
    end
    # Wenn "Q" (L) gedrückt wurde:
    if Input.trigger?(Input::L)
      #Wechsle den aktuellen Actor, sofern das Auswahlfenster aktiv und die
      #Gruppengröße größer als 1 ist:
      return unless @skill_select_window.active and $game_party.actors.size >= 2
      # Spiele Cursorsound
      $game_system.se_play($data_system.cursor_se)
      @actor_id -= 1
      @actor_id %= $game_party.actors.size
      # Update alle nötigen Fenster:
      Graphics.freeze
      refresh_after_actor_changed
      Graphics.transition
      return
    end
  end
 
  #aktualisiere Auswahl und linkes Überschrift-Fenster:
  def refresh_after_actor_changed
    #Linke Überschrift:
    @headline1_window.contents.clear
    @headline1_window.contents.draw_text(0,0,128,32,$game_party.actors[@actor_id].name,1)
    @headline1_window.contents.draw_text(120,0,75,32,IL_LEVEL + " " + $game_party.actors[@actor_id].level.to_s,2)
    #Auswahlfenster:
    @skill_select_window.refresh(@actor_id)
  end  
end