Ruby Quellcode

#===============================================================================
# Erweiterte Status-Effekte V1.3a
#   RTAB - Version
#===============================================================================
# ggf. kritische Methoden:
#   Scene_Battle - refresh_phase(battler)        # Kopiert und modifiziert
#   Scene_Battle - damage_effect(battler, item)  # Kopiert und modifiziert
#   Game_Battler - add_state(i)                  # Rückgabewert eingefügt
 
class Game_Troop
 
  DEFAULT_STATE_CAUSER_ACTOR_ID = 5  # Ersatz-Verursacher für Statuseffekte, 
                        # für die kein anderer Verursacher bekannt ist. Das 
                        # Profil des angegebenen Actors (siehe Zeile 90) wird
                        # vor Beginn eines Kampfes oder beim Script-Aufruf von
                        #     $game_troop.reset_default_causer
                        # zurückgesetzt.
 
end
class Game_Battler
 
  IDENTITY_VAR_ID = 14  # ID der "Identitätsvariablen", die die Database-ID des 
                        # betroffenen Actors bzw. 0 für einen betroffenen Gegner 
                        # speichert
  POSITION_VAR_ID = 15  # ID der "Positionsvariablen", die die Gruppenposition 
                        # eines betroffenen Battlers speichert:
                        # (0 = erstes Mitglied, 1 = zweites Mitglied usw.)
 
  # Liste der Procs für spezielle Statuseffekte. Nicht verändern!
  @@special_states = Hash.new
 
  # Hinzufügen eines Procs für einen speziellen Statuseffekt.
  # state_id : ID des Statuseffekts
  # set      : Code-Basis für den Proc
  def self.set_special_state(state_id, set)
    set = "Proc.new{ |victim, causer| #{set} }"
    @@special_states[state_id] = eval(set)
  end
end
 
begin
  # Im Folgenden können die Statuseinstellungen angepasst werden.
  # Um einen Statuseffekt anzupassen muss folgende Grammatik eingehalten werden:
  #
  #   ID <Eigenschaft> Werteformel
  #
  # Mit:
  # => ID :
  #   Name oder Database-ID des Statuseffekts.
  # => Eigenschaft :
  #   Wirkungsweise des Statuseffekts. Mögliche Eigenschaften sind:
  #   => HP :
  #     Der Statuseffekt verursacht mit jeder Runde zusätzlichen Schaden.
  #   => SP :
  #     Der Statuseffekt entzieht mit jeder Runde zusätzliche SP.
  #   => CE :
  #     Der Statuseffekt ruft mit jeder Runde ein Common-Event auf.
  #     Die Zugehörigkeit sowie die Gruppenposition des Betroffenen werden dabei
  #     in zwei Variablen gespeichert, die in Zeile 22 und 25 dieses Scripts an-
  #     gegeben werden können.
  # => Werteformel:
  #   Hier kann eine Funktion angegeben werden, die als Ergebnis die gewünschte
  #   Zahl ergibt. Gleitkommazahlen werden dabei auf die nächste Ganzzahl 
  #   gerundet. 
  #   Einige Möglichkeiten um eine Funktion zusammenzustellen sind folgende:
  #   
  #    17            # <-- Ganzzahl
  #    17.4          # <-- Gleitkommazahl
  #    17 + 13       # <-- Addition
  #    17 - 13       # <-- Subtraktion
  #    17 * 13       # <-- Multiplikation
  #    17 / 13       # <-- Division
  #                  #   Gelten sowohl der Divisor als auch der Divident als 
  #                  #   Ganzzahl, so wird das Ergebnis abgerundet:
  #                  #    3 / 2 = 1
  #                  #    3.0 / 2.0 = 1.5
  #    17 - (3 + 5)  # <-- Priorität:
  #                  #   Klammersetzung (runde Klammern) und Punkt-vor-Strich-
  #                  #   Regelung werden berücksichtigt.
  #    rand(17)      # <-- Zufallswert:
  #                  #     Ergibt eine zufällige ganze Zahl zwischen 0 und X-1
  #                  #     (Bei 17 entspr. zufällig 0-16)
  #   
  #   Weiterhin können auch bestimmte Werte überprüft werden:
  #
  #   victim.XYZ     # <-- Wert des Betroffenen    (zum aktuellen Zeitpunkt)
  #   causer.XYZ     # <-- Wert des Statusurhebers (zum Zeitpunkt des Wirkens)
  #                  #   Ist kein Statusverursacher bekannt wird das Standard-
  #                  #   Battlerprofil verwendet (siehe Zeile 12)
  #                  #   -> Anmerkung für Scripterfahrene:
  #                  #    Auch wenn die folgenden Befehle für Betroffenen und 
  #                  #    Verursacher identisch sind gehören sie anderen Klassen
  #                  #    an:  victim : Game_Battler
  #                  #         causer : Battler_Profile (siehe Zeile 185ff.)
  #
  #   XYZ muss dabei z.B. durch Folgendes ersetzt werden:
  #   
  #   hp             # <-- HP
  #   maxhp          # <-- maximale HP
  #   sp             # <-- SP
  #   maxsp          # <-- maximale SP
  #   hit            # <-- Trefferchance physischer Angriffe
  #   atk            # <-- Angriffskraft
  #   pdef           # <-- Physische Verteidigung
  #   mdef           # <-- Magische Verteidigung
  #   eva            # <-- Ausweichwertung
  #   str            # <-- Stärke
  #   dex            # <-- Präzision
  #   agi            # <-- Schnelligkeit
  #   int            # <-- Wissen
  #
  #   Wenn für eine Formel mehr als eine Zeile benötigt wird muss die neue
  #   Zeile mit  <>  eingeleitet werden:
  #
  #   Gift <HP>   Testtexttextestextsblubb
  #          <>   NochMehrTextBlabbel...
  #
  #   Bei Zeilenumbrüchen kann es wie im Call-Script-Befehl auch zu Syntax-
  #   fehlern kommen. Daher empfielt es sich einen Zeilenumbruch nur nach einem
  #   Rechen- oder Gleichheitszeichen, einem Komma, einer öffnenden Klammer
  #   oder direkt vor einer schließenden Klammer zu setzen.
  #   Alternativ kann aber auch ein  \  vor den Zeilenumbruch gesetzt werden um
  #   diesen zu überlesen.
  #
#===============================================================================
#         Name/ID        <EG>                 Wirkungsformel
#===============================================================================
  settings = <<-'END_OF_SETTINGS'
 
    Gedankengift         <HP>   20 + causer.int / 5 - victim.mdef / 10
    Gedankengift         <SP>   rand(victim.sp) / 4
    lange Beispielformel <HP>   155 + 132 + (17 - 8) * 6 - 2 * 5 - causer.atk +
                           <>   causer.dex - rand(10 + 14) - 16 + 22 + 42 - 
                           <>   42000 / 5051
    Ruf zu den Wachen    <CE>   17
    Todeszähler          <CE>   15
    Gewitter             <HP>  rand(3) == 0 ? causer.int * 3 : 0
    Gewitter             <SP>  rand(21) + rand(21) - 20 
 
 
 
 
 
 
 
 
  END_OF_SETTINGS
#===============================================================================
# Hier werden die oben angegebenen Statuseffekt-Einstellungen ausgelesen:
 
  # Vorbereitungen:
  $data_states = load_data("Data/States.rxdata")
  collection = Hash.new { |hash, key| hash[key] = Array.new }
  regex = /^[ ]*(.+?)[ ]*<(HP|SP|CE)>[ ]*(.*(?:\n[ ]*<>[ ]*.*)*)/i
  # Einstellungen übersetzen:
  settings.scan(regex) do |result|
    # Status-Index
    name = result[0].strip.upcase
    index = nil
    if (/\d+/ === name) and $data_states[name.to_i] != nil  # ID angegeben
      index = name.to_i
    else                                                    # Name angegeben
      state = $data_states.find { |s| s != nil and s.name.strip.upcase == name }
      index = state.id  if state != nil
    end
    if index != nil
      # Wirkungstyp
      type = result[1].upcase
      # Wirkungsformel (ohne die zeileneinleitenden <>)
      code = result[2].gsub(/(?<=\n)[ ]*<>/, "")
      collection[index].push("victim.state_effect_#{type}((#{code}\n).round); ")
    end
  end
  # Gesammelte Arrays umsetzen:
  collection.each_pair{ |key, set| Game_Battler.set_special_state(key, set) }
end    
 
 
#===============================================================================
# Battler_Profile
#===============================================================================
# Die Klasse  Battler_Profile  dient dazu Informationen zum Zustand des
# Verursachers eines Statuseffektes zu speichern und bei Bedarf abzurufen:
 
class Battler_Profile
 
  attr_reader :hp
  attr_reader :maxhp
  attr_reader :sp
  attr_reader :maxsp
  attr_reader :hit
  attr_reader :atk
  attr_reader :pdef
  attr_reader :mdef
  attr_reader :eva
  attr_reader :str
  attr_reader :dex
  attr_reader :agi
  attr_reader :int
 
  # Initialisierung:
  def initialize(battler)
    # Battler-Kennung:
    @membership_id = battler.is_a?(Game_Actor) ? -1 : $game_troop.troop_count
    @member_index  = battler.is_a?(Game_Actor) ? battler.id : battler.index
    # Battlerwerte zum Zeitpunkt der Erstellung:
    @hp    = battler.hp 
    @maxhp = battler.maxhp
    @sp    = battler.sp
    @maxsp = battler.maxsp
    @hit   = battler.hit
    @atk   = battler.atk
    @pdef  = battler.pdef
    @mdef  = battler.mdef
    @eva   = battler.eva
    @str   = battler.str
    @dex   = battler.dex
    @agi   = battler.agi
    @int   = battler.int
  end
 
  # Versucht den zugeordneten Battler zu ermitteln:
  def battler
    troop = $game_troop
    return troop.enemies[@member_index] if @membership_id == troop.troop_count
    return $game_actors[@member_index]  if @membership_id == -1
    return nil
  end
end
 
 
#===============================================================================
# Game_Troop
#===============================================================================
# Jede Truppe hat nun eine einzigartige, fortlaufende Nummer.
# Diese wird in  Battler_Profile  verwendet um zu unterscheiden ob ein 
# gegnerischer Statusverursacher noch zur aktuell bekämpften Truppe gehört.
# Auch das Ersatz-Statusverursacherprofil wird hier verwaltet.
 
class Game_Troop
 
  attr_reader  :troop_count     # <-- Nummer der aktuell bekämpften Truppe
  attr_reader  :default_causer  # <-- Ersatz-Statusverursacherprofil
 
  # Initialisierung:
  alias_method(:initialize_ILC_special_states, :initialize)
  def initialize(*args)
    @troop_count = 0
    @default_causer = nil
    initialize_ILC_special_states(*args)
  end
 
  # Setup einer neuen Truppe:
  alias_method(:setup_ILC_special_states, :setup)
  def setup(*args)
    @troop_count += 1
    setup_ILC_special_states(*args)
    reset_default_causer
  end
 
  # Ersatz-Statusverusacher zurücksetzen:
  def reset_default_causer
    actor = $game_actors[DEFAULT_STATE_CAUSER_ACTOR_ID]
    @default_causer = Battler_Profile.new(actor)
  end
end
 
 
#===============================================================================
# Game_Battler:
#===============================================================================
# Es werden zusätzliche Statuseinstellungen verwaltet
 
class Game_Battler
 
  # Initialisierung:
  alias_method(:initialize_ILC_special_states, :initialize)
  def initialize(*args)
    # Verursacher spezieller Statuseffekte:
    @state_causers = Hash.new
    @events_called = Array.new 
    initialize_ILC_special_states(*args)
  end
 
  #=============================================================================
  # Verwaltung des Verursachers spezieller Statuseffekte:
  #=============================================================================
 
  # Setze das Profil eines neuen Verursachers fest:
  # state_id : ID des Statuseffekts
  # battler  : Verursacher (Game_Battler) oder  nil  zum entfernen des Eintrags.
  def set_state_causer(state_id, battler)
    if @@special_states[state_id] != nil
      if battler == nil
        # Verursacher wird entfernt:
        @state_causers.delete(state_id)
      else
        # Verursacher-Informationen werden gespeichert:
        @state_causers[state_id] = Battler_Profile.new(battler)
      end
    end
  end
 
  # Bestimme den Verursacher eines Statuseffekts:
  def state_causer(state_id)
    profile = @state_causers[state_id]
    return profile == nil ? $game_troop.default_causer : profile
  end
 
  #=============================================================================
  # Setze Verursacher eines Statuseffekts bei neuen Effekten:
  #=============================================================================
 
  # Füge Statuseffekt hinzu:
  # Die Methode gibt nun <true> zurück wenn sich die Dauer geändert hat:
  alias_method(:add_state_ILC_special_states, :add_state)
  def add_state(state_id, force = false)
    last_turn = @states_turn[state_id]
    add_state_ILC_special_states(state_id, force)
    # Setze Verursacher zurück wenn sich die Dauer des Effekts geändert hat:
    effective = (@states_turn[state_id] != last_turn)
    set_state_causer(state_id, nil)  if effective
    return effective
  end    
 
  # Entferne Statuseffekt:
  alias_method(:remove_state_ILC_special_states, :remove_state)
  def remove_state(state_id, force = false)
    remove_state_ILC_special_states(state_id, force)
    # Setze Verursacher zurück wenn der Effekt entfernt wurde:
    set_state_causer(state_id, nil)  if @states_turn[state_id] == nil
  end
 
 
  #--------------------------------------------------------------------------
  # ● ダメージ演算
  #--------------------------------------------------------------------------
  # Modifizierte Originalmethode:
  #  Setze Verursacher bei veränderten Statuseffekten:
  def damage_effect(battler, item)
    if item == 2
      self.hp += self.recover_hp[battler]
      self.sp += self.recover_sp[battler]
      if self.recover_sp[battler] != 0
        self.damage_sp[battler] = -self.recover_sp[battler]
      end
      self.recover_hp.delete(battler)
      self.recover_sp.delete(battler)
    else
      if self.damage[battler].class != String
        self.hp -= self.damage[battler]
      end
    end
    for i in self.state_p[battler]
      effective = add_state(i)
      set_state_causer(i, battler)  if effective  # EINGEFÜGT
    end
    for i in self.state_m[battler]
      remove_state(i)
    end
  end
 
  #=============================================================================
  # Aktualisierung der speziellen Statuseffekte:
  #=============================================================================
 
  # Aktualisierung aller speziellen Statuseffekte:
  def update_special_states
    @events_called.clear  # Zurücksetzen der aufzurufenden Common-Events
    states.dup.each do |id|
      proc = @@special_states[id]
      proc.call(self, state_causer(id))  if proc != nil
    end
  end
 
  # HP-Schaden erleiden durch einen speziellen Statuseffekt
  # Wird durch Statusprocs in  update_special_states  aufgerufen.
  #  amount : Höhe des Schadens (negativ = Heilung)
  def state_effect_HP(amount)
    key = Object.new
    @damage[key] = amount
    @damage_pop[key] = true
    self.hp -= amount
  end
 
  # SP-Schaden erleiden durch einen speziellen Statuseffekt
  # Wird durch Statusprocs in  update_special_states  aufgerufen.
  #  amount : Höhe des Schadens (negativ = Wiederherstellung)
  def state_effect_SP(amount)
    key = Object.new
    @damage_sp[key] = amount
    @damage_pop[key] = true
    self.sp -= amount
  end
 
  # Common-Event reservieren durch einen speziellen Statuseffekt
  # Wird durch Statusprocs in  update_special_states  aufgerufen.
  #  id : ID des Common-Events
  def state_effect_CE(id)
    @events_called.push(id)  if id > 0
  end
 
  # Nächstes Common-Event vorbereiten sofern vorhanden:
  def get_called_event
    while not @events_called.empty?
      common_event = $data_common_events[@events_called.pop]
      if common_event != nil
        # Identitätsvariablen setzen:
        $game_variables[IDENTITY_VAR_ID] = self.is_a?(Game_Actor) ? self.id : 0
        $game_variables[POSITION_VAR_ID] = self.index
        $game_map.need_refresh = true
        # Common-Event zurückgeben:
        return common_event
      end
    end
    # 'nil' zurückgeben wenn kein Common-Event mehr aufgerufen werden muss
    return nil
  end
end
 
 
#===============================================================================
# Scene_Battle:
#===============================================================================
# Es werden ein paar Änderungen eingefügt um die durch die Statuseffekte
# verursachten Common-Events abfangen und ausführen zu können:
 
class Scene_Battle
 
  # Main:
  # Erstellt zusätzlich eine Liste für ausstehende Status-CEs:
  alias_method(:main_ILC_SSE13plusRTAB, :main)
  def main
    @state_common_event_battlers = []
    main_ILC_SSE13plusRTAB
  end
 
  # Setup Battle Event:
  # Überprüft nun vorrangig ausstehende Status-CEs:
  alias_method(:setup_battle_event_ILC_SSE13plusRTAB, :setup_battle_event)
  def setup_battle_event
    check_state_called_event
    setup_battle_event_ILC_SSE13plusRTAB
  end
 
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  # Modifizierte Originalmethode:
  # Aktualisiere spezielle Statuseffekte
  def refresh_phase(battler)
    battler.at -= @max
    if battler.movable?
      battler.atp = 100 * battler.at / @max
    end
    spell_reset(battler)
    # スリップダメージ
    if battler.hp > 0 and battler.slip_damage?
      battler.slip_damage_effect
      battler.damage_pop["slip"] = true
    end
    # => EINGEFÜGT: Überprüfe aktive spezielle Statuseffekte:
    battler.update_special_states
    # ステート自然解除
    battler.remove_states_auto
    # ステータスウィンドウをリフレッシュ
    status_refresh(battler, true)
    unless battler.movable?
      return
    end
    # ターン数カウント
    @turn_cnt += 1
    # => EINGEFÜGT: Füge den Battler zur Status-CE-Liste hinzu:
    @state_common_event_battlers.push(battler)
  end
 
  #--------------------------------------------------------------------------
  # ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
  #--------------------------------------------------------------------------
  alias_method(:update_phase4_step6_ILC_SSE13plusRTAB, :update_phase4_step6)
  def update_phase4_step6(battler)
    update_phase4_step6_ILC_SSE13plusRTAB(battler)
    # Starte Abarbeitung der Status-CEs:
    check_state_called_event
  end
 
  # Überprüfe ob weitere Status-Commonevents abgearbeitet werden müssen:
  # Sollte nach dem automatischen Entfernen von Statuseffekten und vor dem
  # Ausführen der nächsten Aktion aufgerufen werden.
  def check_state_called_event
    while not $game_system.battle_interpreter.running? and 
          not @state_common_event_battlers.empty?
      common_event = @state_common_event_battlers[0].get_called_event
      if common_event != nil
        # Starte das nächste, noch nicht abgearbeitete Status-Event:
        $game_system.battle_interpreter.setup(common_event.list, 0)
      else
        # Entferne den Battler sobald seine Statuseffekte abgearbeitet wurden
        @state_common_event_battlers.shift
      end
    end
  end
end