CTB - A Final Fantasy X-like Battle System, Version 3.2

[Charlie Fleed]

All those are debug messages, I forgot to remove them... :P
Here's the cleaned version:

Content Hidden

Code:

#==============================================================================
# ** Summons (Add-on for the Custom Battle System (CTB) by Charlie Lee)
#
# Version:           0.7        
# Author:    Charlie Lee
#==============================================================================
#==============================================================================
# ?                         *** CONFIGURATION ***                           ? #
#==============================================================================

# This is used for the identification of summon skills and has nothing to do
# with the command name in the actor command window
SUMMON_NAME="Summon"

RETIRE_NAME="Retire"

AUTO_ADD_ACTORS = true

# Items usability
TYPE_1_CAN_USE_ITEMS = false
TYPE_2_CAN_USE_ITEMS = false
USE_ITEMS_ON_TYPE_1 = false
USE_ITEMS_ON_TYPE_2 = false

# Experience acquisition
REMOVED_ACTORS_EXP_MULTIPLIER = 0.8
TRANSFORMED_ACTORS_EXP_MULTIPLIER = 0.8 # Applies to actors not in their
# original form at the end of the battle. The transformed form gets full exp
INVOKED_AEON_EXP_MULTIPLIER = 0.8
NOT_INVOKED_AEON_EXP_MULTIPLIER = 0.2
INVOKED_TRANSFORMATION_EXP_MULTIPLIER = 0.8
NOT_INVOKED_TRANSFORMATION_EXP_MULTIPLIER = 0.2


# Use this if you want dead aeons to be unavailable for N battles
# For multiple invocations it only applies if all the aeons have been killed
# For aoens summoned with multiple summons it only applies to the summon that
# was active when they were killed
BATTLES_BEFORE_AEONS_RETURN = 2

# Aeons recover HP_RECOVER percent of HPs
# at the end of every battle
HP_RECOVER = 10
# Aeons recover SP_RECOVER percent of SPs
# at the end of every battle
SP_RECOVER = 10
# Transformations recover HP_RECOVER percent of HPs
# at the end of every battle
HP_RECOVER3 = 10
# Transformations recover SP_RECOVER percent of SPs
# at the end of every battle
SP_RECOVER3 = 10

REMOVE_DEAD_SUMMONS = true

AEONS_LEARNINGS={
1 => [17,5],
2 => [17,15],
3 => [17,30],
54 => [14,5]
} # {skill_id => [item, quantity]}

TRANSFORMED_ACTOR_ANIMATION_ID=22
SUMMONED_ACTORS_ANIMATION_ID=20
RETURNING_PARTY_ANIMATION_ID=2

#==============================================================================
# ? SUMMON
# type: 1) do not remove party actors, 2) remove party actors,
# 3) remove the summoned (aka transformations)
#==============================================================================
class Summon
  attr_reader     :actors_ids
  attr_reader     :actors_names
  attr_reader     :type
  attr_reader     :skill_id
  attr_accessor   :available
  attr_reader     :key
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(type,id,names,key)
    @available=0
    @type=type
    @skill_id=id
    @key=key
    @actors_names=[]
    @actors_ids=[]
    for name in names
      for i in 0...999
        actor = $game_actors[i]
        if actor != nil and actor.name == name
          @actors_ids.push(actor.id)
          $game_party.aeons_ids.push(actor.id) unless type==3
          $game_party.transformations_ids.push(actor.id) if type==3
          @actors_names.push(name)
        end
      end
    end
    # output
  end
  #--------------------------------------------------------------------------
  # * Output
  #--------------------------------------------------------------------------
  def output
    print("Summon skill id: "+@skill_id.to_s+"\ntype: "+type.to_s)
    print("Actors:")
    for actor_name in @actors_names
      print(actor_name)
    end
  end
end


#==============================================================================
# ? GAME_PARTY
#==============================================================================
class Game_Party
  attr_accessor :aeons              # array of Aeons in the game party
  attr_accessor :transformations    # array of Transformations in the game party
  attr_accessor :removed_actors
  attr_accessor :aeons_ids          # array of all the aeons' ids
  attr_accessor :transformations_ids  # array of all the transformations' ids
  attr_accessor :game_summons       # array of all the Summons
  attr_accessor :transformed_actors
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  alias summon_initialize initialize
  def initialize
    summon_initialize
    @aeons=[]
    @transformations=[]
    @removed_actors=[]
    @aeons_ids=[]
    @transformations_ids=[]
    @game_summons=[]
    @transformed_actors=[]
  end
  #--------------------------------------------------------------------------
  # * Fill Summons Database
  #--------------------------------------------------------------------------
  def fill_summons_database
    $game_temp.filling_summons_database=true
    # print("filling_summons_database")
    for skill in $data_skills
      @filling_summons_database_skill_id=skill.id
      if skill!=nil and skill.element_set.include?($game_temp.summon_element_id)
        # print("summon: "+skill.name+" id"+skill.id.to_s)
        id=skill.common_event_id
        command=""
        for line in $data_common_events[id].list
          command=command+line.parameters[0].to_s
        end
        # print(command)
        eval(command)
      end
    end
    $game_temp.filling_summons_database=false
  end
  #--------------------------------------------------------------------------
  # * Summon
  #--------------------------------------------------------------------------
  def summon(type,actors_names,key=-1)
    if $game_temp.filling_summons_database==true
      # create the summon
      skill_id=@filling_summons_database_skill_id
      @game_summons[skill_id]=Summon.new(type,skill_id,actors_names,key)
      if $game_temp.auto_add_aeons_list.include?(skill_id)
        if type==1 or type==2
          for actor_id in $game_party.game_summons[skill_id].actors_ids
            if not $game_party.aeons.include?($game_actors[actor_id])
              $game_party.aeons.push($game_actors[actor_id])
            end
          end
        else
          for actor_id in $game_party.game_summons[skill_id].actors_ids
            if not $game_party.transformations.include?($game_actors[actor_id])
              $game_party.transformations.push($game_actors[actor_id])
            end
          end
        end
      end
    else
      for summon in @game_summons
        if summon != nil
          if summon.type == type and summon.actors_names==actors_names and
            (summon.key==-1 or summon.key==key)
            $scene.summon(summon)
          end
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Add Summoned
  #--------------------------------------------------------------------------
  def add_summoned(actor_id, position=-1)
    # Get actor
    actor = $game_actors[actor_id]
    if not @actors.include?(actor)
      # Add actor
      if position>=0
        @actors.insert(position,actor)
      else
        @actors.push(actor)
      end
      actor.battle_data_reset
      actor.randomize_next_action_time
    end
    $game_player.refresh
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
  end
  #--------------------------------------------------------------------------
  # * Remove Party
  #--------------------------------------------------------------------------
  def remove_party()
    to_be_removed=[]
    @removed_actors=[]
    for actor in @actors
      to_be_removed.push(actor)
    end
    for actor in to_be_removed
      # Remove actor
      @actors.delete(actor)
      # Add actor to the removed actors array
      @removed_actors.push(actor)
    end
    $game_temp.party_removed = true
    $game_player.refresh
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
  end
  #--------------------------------------------------------------------------
  # * Return Party
  #--------------------------------------------------------------------------
  def return_party
    # p "return party"
    # print("removed actors size: "+ @removed_actors.size.to_s)
    for actor in @removed_actors
      # Add actor
      @actors.push(actor)
      actor.battle_data_reset(false) # Do not reset the last commands
      actor.randomize_next_action_time
    end
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
    size=@removed_actors.size
    @removed_actors.clear
    $game_temp.party_removed = false
    $game_player.refresh
    # return the # of actors
    return size
  end

  #--------------------------------------------------------------------------
  # * Return Transformed Actor
  #--------------------------------------------------------------------------
  def return_transformed_actor(id)
    for a in @transformed_actors
      if a.id == id
        actor=a
      end
    end
    # Add actor
    @actors.push(actor)
    actor.battle_data_reset
    actor.randomize_next_action_time
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
  end
  #--------------------------------------------------------------------------
  # * Return Transformed Backup Actor
  #--------------------------------------------------------------------------
  def return_transformed_backup_actor(id)
    for a in @transformed_actors
      if a.id == id
        actor=a
      end
    end
    # Add actor
    @backup_actors.push(actor)
    actor.battle_data_reset
    actor.randomize_next_action_time
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
  end

  def update_size
    @party_size=$game_party.actors.size
  end
  
  #--------------------------------------------------------------------------
  # * Add an Actor
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  alias summon_add_actor add_actor
  def add_actor(actor_id)
    # Original call
    summon_add_actor(actor_id)
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
  end
  #--------------------------------------------------------------------------
  # * Remove Actor
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  alias summon_remove_actor remove_actor
  def remove_actor(actor_id)
    # Original call
    summon_remove_actor(actor_id)
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
  end
  
  def summons_hp_recover
    for actor in $game_party.aeons
      actor.hp = Integer([actor.maxhp,actor.hp+actor.maxhp*HP_RECOVER/100].min)
    end
    for actor in $game_party.transformations
      actor.hp = Integer([actor.maxhp,actor.hp+actor.maxhp*HP_RECOVER3/100].min)
    end
  end
  def summons_sp_recover
    for actor in $game_party.aeons
      actor.sp = Integer([actor.maxsp,actor.sp+actor.maxsp*SP_RECOVER/100].min)
    end
    for actor in $game_party.transformations
      actor.sp = Integer([actor.maxsp,actor.sp+actor.maxsp*SP_RECOVER3/100].min)
    end
  end

  #--------------------------------------------------------------------------
  # * Remove Transformed
  #--------------------------------------------------------------------------
  def remove_transformed(id)
    for a in @actors
      if a.id==id
        actor=a
        # Save position
        temp=@actors.index(a)
      end
    end
    # Remove actor
    @actors.delete(actor)
    # Add actor to the removed actors array
    @transformed_actors.push(actor)
    $game_player.refresh
    # THIS LINE IS FOR COMPATIBILITY WITH MINKOFF/DERVVULFMAN ANIMATION SYSTEM
    update_size
    return temp
  end
  
  #--------------------------------------------------------------------------
  # * Refresh Party Members
  #--------------------------------------------------------------------------
  alias summon_refresh refresh
  def refresh
    # Original call
    summon_refresh
    # Actor objects split from $game_actors right after loading game data
    # Avoid this problem by resetting the actors each time data is loaded.
    new_actors = []
    for i in 0...@aeons.size
      if $data_actors[@aeons[i].id] != nil
        new_actors.push($game_actors[@aeons[i].id])
      end
    end
    @aeons = new_actors
    new_actors = []
    for i in 0...@backup_actors.size
      if $data_actors[@backup_actors[i].id] != nil
        new_actors.push($game_actors[@backup_actors[i].id])
      end
    end
    @backup_actors = new_actors
    new_actors = []
    for i in 0...@transformations.size
      if $data_actors[@transformations[i].id] != nil
        new_actors.push($game_actors[@transformations[i].id])
      end
    end
    @transformations = new_actors
  end
end


#==============================================================================
# ? SPRITESET BATTLE
#==============================================================================
class Spriteset_Battle
  def add_sprites(n=1)
    added_sprites=[]
    for i in 1..n
      actor_sprite=Sprite_Battler.new(@viewport1)
      @actor_sprites.push(actor_sprite)
      added_sprites.push(actor_sprite)
      # print("add_sprite")
    end
    return added_sprites
  end

  def add_sprite_in_pos(pos)
    actor_sprite=Sprite_Battler.new(@viewport1)
    actor_sprite.appear
    @actor_sprites.insert(pos, actor_sprite)
    return actor_sprite
    # print("add_sprite")
  end

  def remove_sprites(n=1)
    for i in 1..n
      # print("remove sprite")
      sprite=@actor_sprites.pop
      sprite.battler=nil
      sprite.dispose
    end
  end

  def remove_sprite_in_pos(pos)
    sprite=@actor_sprites.delete_at(pos)
    sprite.battler=nil
    sprite.dispose
  end
  
  alias summon_update update
  def update
    @actor_sprites.each_index do |index| @actor_sprites[index].battler =
      $game_party.actors[index] end
    summon_update
  end  
end

#==============================================================================
# ? SCENE BATTLE
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Initialize invoked_during_last_battle flag
  #--------------------------------------------------------------------------
  alias summon_start_phase1 start_phase1
  def start_phase1
    for aeon in $game_party.aeons
      aeon.invoked_during_last_battle = false
    end
    for transformation in $game_party.transformations
      transformation.invoked_during_last_battle = false
    end
    summon_start_phase1
  end
  #--------------------------------------------------------------------------
  # * Summon
  #--------------------------------------------------------------------------
  def summon(s)
    # print("Scene Battle")
    # s.output
    # If the summon adds characters to the party
    if s.type==1
      if $game_party.actors.size + s.actors_ids.size > 8
        $game_temp.too_many_actors = true
        return
      end
      # Add the actors
      for actor_id in s.actors_ids
        $game_party.add_summoned(actor_id)
        # Set the invoked flag
        $game_actors[actor_id].invoked_during_last_battle = true
        added_sprites=[]
        added_sprites=@spriteset.add_sprites
        for sprite in added_sprites; sprite.animation($data_animations[SUMMONED_ACTORS_ANIMATION_ID],true) unless SUMMONED_ACTORS_ANIMATION_ID==nil; end
      end
      for actor_id in s.actors_ids
        $game_actors[actor_id].summon_id=s.skill_id
        # print($game_actors[actor_id].summon_id.to_s)
      end
      return
    elsif s.type==2
      # Remove the sprites
      @spriteset.remove_sprites($game_party.actors.size)
      $game_party.remove_party
      # Add the actors
      for actor_id in s.actors_ids
        $game_party.add_summoned(actor_id)
        # Set the invoked flag
        $game_actors[actor_id].invoked_during_last_battle = true
        added_sprites=[]
        added_sprites=@spriteset.add_sprites
        for sprite in added_sprites; sprite.animation($data_animations[SUMMONED_ACTORS_ANIMATION_ID],true) unless SUMMONED_ACTORS_ANIMATION_ID==nil; end
      end
      for actor_id in s.actors_ids
        $game_actors[actor_id].summon_id=s.skill_id
        # print($game_actors[actor_id].summon_id.to_s)
      end
      return
    elsif s.type==3
      # Remove the sprite
      party_position=$game_party.remove_transformed(@active_battler.id)
      @spriteset.remove_sprite_in_pos(party_position)
      # Add the actors
      for actor_id in s.actors_ids
        $game_party.add_summoned(actor_id, party_position)
        sprite=@spriteset.add_sprite_in_pos(party_position)
        sprite.animation($data_animations[TRANSFORMED_ACTOR_ANIMATION_ID],true) unless TRANSFORMED_ACTOR_ANIMATION_ID==nil
      end
      for actor_id in s.actors_ids
        $game_actors[actor_id].summon_id=s.skill_id
        # Save the original form id
        $game_actors[actor_id].original_form_id=@active_battler.id
        # Save the transformed form id
        @active_battler.transformed_form_id=actor_id
        # print($game_actors[actor_id].summon_id.to_s)
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Return Party    # This method deals with the sprites
  #--------------------------------------------------------------------------
  def return_party
    # p "return party"
    n_of_returned_members=$game_party.return_party
    for i in 1..n_of_returned_members
        added_sprites=[]
        added_sprites=@spriteset.add_sprites
        for sprite in added_sprites; sprite.animation($data_animations[RETURNING_PARTY_ANIMATION_ID],true) unless RETURNING_PARTY_ANIMATION_ID==nil; end
      # p "Adding sprite"
    end
  end  
  #--------------------------------------------------------------------------
  # * Battle_End
  #--------------------------------------------------------------------------
  alias summon_battle_end battle_end
  def battle_end(n)
    # HP recover for aeons
    $game_party.summons_hp_recover
    # SP recover for aeons
    $game_party.summons_sp_recover
    for s in $game_party.game_summons
      if s != nil
        s.available=[s.available-1,0].max
      end
    end

    # Remove all the summoned actors
    to_be_removed=[]
    for actor in $game_party.actors
      if $game_party.aeons_ids.include?(actor.id)
        to_be_removed.push(actor)
        # print("removed ", actor.name)
      end
    end
    for actor in to_be_removed
      $game_party.actors.delete(actor)
    end
    # Let the party return, no need to add any sprites, so we call the
    # class Game_Party method
    $game_party.return_party
    # Remove all the summoned actors from the returned party
    to_be_removed=[]
    for actor in $game_party.actors
      if $game_party.aeons_ids.include?(actor.id)
        to_be_removed.push(actor)
        # print("removed ", actor.name)
      end
    end
    for actor in to_be_removed
      $game_party.actors.delete(actor)
    end
    
    # Remove all the transformed actors from the party
    to_be_removed=[]
    for actor in $game_party.actors
      if $game_party.transformations_ids.include?(actor.id)
        to_be_removed.push(actor)
        # print("removed ", actor.name)
      end
    end
    for actor in to_be_removed
      $game_party.actors.delete(actor)
      $game_party.return_transformed_actor(actor.original_form_id)
    end
    # Remove all the transformed actors from the backup party
    to_be_removed=[]
    for actor in $game_party.backup_actors
      if $game_party.transformations_ids.include?(actor.id)
        to_be_removed.push(actor)
        # print("removed ", actor.name)
      end
    end
    for actor in to_be_removed
      $game_party.backup_actors.delete(actor)
      $game_party.return_transformed_backup_actor(actor.original_form_id)
    end
    $game_player.refresh
    # Original call
    summon_battle_end(n)
  end
  #--------------------------------------------------------------------------
  # * Retire    # This method does not deal with sprites
  #--------------------------------------------------------------------------
  def retire(summon_id)
    # Remove all the actors summoned with the retiring battler's summon
    #p summon_id.to_s
    #p $game_party.game_summons[summon_id].type.to_s
    to_be_removed_ids = $game_party.game_summons[summon_id].actors_ids
    for actor_id in to_be_removed_ids
      $game_party.remove_actor(actor_id)
    end
    @spriteset.remove_sprites(to_be_removed_ids.size)
    # Make the party return if the summon was type 2
    if $game_party.game_summons[summon_id].type == 2
      return_party
    end
    $game_party.update_size # can be removed?
  end
  #--------------------------------------------------------------------------
  # * Determine Battle Win/Loss Results
  #--------------------------------------------------------------------------
  alias summon_judge judge
  def judge
    # If all dead determinant is true, or number of members in party is 0
    if $game_party.all_dead? or $game_party.actors.size == 0
      # If the party has been removed
      if $game_party.removed_actors.size > 0
        to_be_removed=[]
        # Remove all the summoned actors
        for actor in $game_party.actors
          if $game_party.aeons_ids.include?(actor.id)
            to_be_removed.push(actor)
          end
        end
        for actor in to_be_removed
          # print("remove"+actor.name)
          $game_party.actors.delete(actor)
          $game_party.game_summons[actor.summon_id].available = BATTLES_BEFORE_AEONS_RETURN + 1
        end
        $game_party.update_size # can be removed?
        @spriteset.remove_sprites(to_be_removed.size)
        @spriteset.update
        # Party return
        return_party
        $game_party.update_size # can be removed?
        @spriteset.update
        # It isn't over yet!
        return false
      end
    end
    # Remove dead summon
    if REMOVE_DEAD_SUMMONS
      initial_actors=$game_party.actors
      for actor in initial_actors
        # initial actors may not be in the party anymore after some retirements
        if $game_party.actors.include?(actor)
          # if actor is summoned
          if $game_party.aeons_ids.include?(actor.id)
            remove = true
            to_be_tested_ids = $game_party.game_summons[actor.summon_id].actors_ids
            for actor_id in to_be_tested_ids
              remove = false unless $game_actors[actor_id].dead?
            end
          end
          if remove
            retire(actor.summon_id)
            @spriteset.update
            $game_party.game_summons[actor.summon_id].available = BATTLES_BEFORE_AEONS_RETURN + 1
          end
        end
      end
    end
    # original call
    return summon_judge
  end
  
  #--------------------------------------------------------------------------
  # * Start After Battle Phase
  #--------------------------------------------------------------------------
  alias summon_start_phase5 start_phase5
  def start_phase5
    exp = 0
    # Loop
    for enemy in $game_troop.enemies
      # If enemy is not hidden
      unless enemy.hidden
        # Add EXP and amount of gold obtained
        exp += enemy.exp
      end
    end
    # Actors removed for summon (can be aeons or transformations)
    for actor in $game_party.removed_actors
      actor.old_exp=actor.exp
      actor.exp += (actor.state?($expx2_state_id)?2:1) * Integer(exp * REMOVED_ACTORS_EXP_MULTIPLIER)
    end
    # Original form of transformed actors
    for actor in $game_party.transformed_actors
      actor.old_exp=actor.exp
      # if removed
      if $game_party.removed_actors.include?($game_actors[actor.transformed_form_id])
        # print(actor.name + " transformed and removed")
        actor.exp += (actor.state?($expx2_state_id)?2:1) * Integer(exp * TRANSFORMED_ACTORS_EXP_MULTIPLIER * REMOVED_ACTORS_EXP_MULTIPLIER)
      # if switched
      elsif $game_party.backup_actors.include?($game_actors[actor.transformed_form_id])
        # print(actor.name + " transformed and switched")
        actor.exp += (actor.state?($expx2_state_id)?2:1) * Integer(exp * TRANSFORMED_ACTORS_EXP_MULTIPLIER * SWITCHED_ACTORS_EXP_MULTIPLIER)
      else
        # print(actor.name + " transformed")
        actor.exp += (actor.state?($expx2_state_id)?2:1) * Integer(exp * TRANSFORMED_ACTORS_EXP_MULTIPLIER)
      end
    end
    # Aeons not in the party
    for aeon in $game_party.aeons-$game_party.actors
      aeon.old_exp=aeon.exp
      # p aeon.name
      aeon.exp += Integer(exp *
      ((aeon.invoked_during_last_battle)?(INVOKED_AEON_EXP_MULTIPLIER):(NOT_INVOKED_AEON_EXP_MULTIPLIER)))
    end
    # Transformations not in the party or the backup party or the removed actors
    for transformation in ((($game_party.transformations-$game_party.actors)-$game_party.backup_actors)-$game_party.removed_actors)
      transformation.old_exp=transformation.exp
      # p transformation.name
      transformation.exp += Integer(exp *
      ((transformation.invoked_during_last_battle)?(INVOKED_TRANSFORMATION_EXP_MULTIPLIER):(NOT_INVOKED_TRANSFORMATION_EXP_MULTIPLIER)))
    end
    # Call the original script
    summon_start_phase5
  end
end

#==============================================================================
# ? GAME TEMP
#==============================================================================
class Game_Temp
  attr_accessor :too_many_actors
  attr_accessor :summon_element_id
  attr_accessor :filling_summons_database
  attr_accessor :party_removed
  attr_accessor :actors_transformed
  attr_accessor :auto_add_aeons_list
  alias initialize_summons initialize
  def initialize
    # Perform the original call
    initialize_summons
    @too_many_actors = false
    @summon_element_id = $data_system.elements.index(SUMMON_NAME)
    @party_removed = false
    @actors_transformed = false
    @auto_add_aeons_list = []
  end
end

#==============================================================================
# ? GAME BATTLER
#==============================================================================
class Game_Battler
  attr_accessor :summon_id
  #--------------------------------------------------------------------------
  # * Retire
  #--------------------------------------------------------------------------
  def retire
    $scene.retire(@summon_id)
  end
end

#==============================================================================
# ? SCENE TITLE
#==============================================================================
class Scene_Title
  #--------------------------------------------------------------------------
  # * Command: New Game
  #--------------------------------------------------------------------------
  alias summon_command_new_game command_new_game
  def command_new_game
    summon_command_new_game
    $game_party.fill_summons_database
  end
end

#==============================================================================
# ? GAME ACTOR
#==============================================================================
class Game_Actor < Game_Battler
  attr_accessor :invoked_during_last_battle
  #--------------------------------------------------------------------------
  # * Determine if Skill can be Used
  #     skill_id : skill ID
  #--------------------------------------------------------------------------
  alias summon_skill_can_use? skill_can_use?
  def skill_can_use?(skill_id)
    # If skill is a summon
    if $data_skills[skill_id].element_set.include?($game_temp.summon_element_id)
      if $game_party.game_summons[skill_id].available > 0
        return false
      end
      # return false if the party has been removed
      if $game_party.game_summons[skill_id].type == 2 and
        $game_temp.party_removed
        return false
      end
      # return false if some of the actors is already in the party
      for actor_id in $game_party.game_summons[skill_id].actors_ids
        if $game_party.actors.include?($game_actors[actor_id])
          return false
        end
      end
      # return false if some of the actors is already in the backup party
      for actor_id in $game_party.game_summons[skill_id].actors_ids
        if $game_party.backup_actors.include?($game_actors[actor_id])
          return false
        end
      end
      # return false if all the actors are dead
      all_dead=true
      for actor_id in $game_party.game_summons[skill_id].actors_ids
        if not $game_actors[actor_id].dead?
          all_dead = false
        end
      end
      return false if all_dead
    end
    # Perform the original call
    return summon_skill_can_use?(skill_id)
  end
  
  def summon_skill_can_learn?(skill_id)
    return false if AEONS_LEARNINGS[skill_id] == nil
    return false if skill_learn?(skill_id)
    item_needed=AEONS_LEARNINGS[skill_id][0]
    quantity_needed=AEONS_LEARNINGS[skill_id][1]
    if $game_party.item_number(item_needed) < quantity_needed
      return false
    else
      return true
    end
  end
  
  alias summon_learn_skill learn_skill
  def learn_skill(skill_id)
    summon_learn_skill(skill_id)
    return unless AUTO_ADD_ACTORS
    if $data_skills[skill_id].element_set.include?($game_temp.summon_element_id)
      if skill_learn?(skill_id)
        if $game_party.game_summons!=[]
          if $game_party.game_summons[skill_id].type != 3
            for actor_id in $game_party.game_summons[skill_id].actors_ids
              if not $game_party.aeons.include?($game_actors[actor_id])
                $game_party.aeons.push($game_actors[actor_id])
              end
            end
          else
            for actor_id in $game_party.game_summons[skill_id].actors_ids
              if not $game_party.transformations.include?($game_actors[actor_id])
                $game_party.transformations.push($game_actors[actor_id])
              end
            end
          end
        else
          $game_temp.auto_add_aeons_list.push(skill_id) unless $game_temp.auto_add_aeons_list.include?(skill_id)
        end
      end
    end
  end
  
end

#==============================================================================
# ? SCENE BATTLE
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Determine if the Item command is available for summons
  #--------------------------------------------------------------------------
  alias summons_phase3_setup_command_window2 phase3_setup_command_window2
  def phase3_setup_command_window2
    if @active_battler.summon_id != nil
      t=$game_party.game_summons[@active_battler.summon_id].type
      if t==1
        @individual_battle_commands.delete($data_system.words.item) unless TYPE_1_CAN_USE_ITEMS
      elsif t==2
        @individual_battle_commands.delete($data_system.words.item) unless TYPE_2_CAN_USE_ITEMS        
      end
    end
    # original call
    summons_phase3_setup_command_window2
  end

  #--------------------------------------------------------------------------
  # * Determine if the item can be used on summons
  #--------------------------------------------------------------------------
  alias summons_update_phase3_actor_select2 update_phase3_actor_select2
  def update_phase3_actor_select2
    # If item window is showing
    if @item_window != nil
      # If C button was pressed
      if Input.trigger?(Input::C)
        if $game_party.actors[@actor_arrow.index].summon_id != nil
          t=$game_party.game_summons[$game_party.actors[@actor_arrow.index].summon_id].type
          if t==1
            if not USE_ITEMS_ON_TYPE_1
              # Play buzzer SE
              $game_system.se_play($data_system.buzzer_se)
              return
            end
          elsif t==2
            if not USE_ITEMS_ON_TYPE_2
              # Play buzzer SE
              $game_system.se_play($data_system.buzzer_se)
              return
            end
          end
        end
      end
    end
    # Original call
    summons_update_phase3_actor_select2
  end
  
  #--------------------------------------------------------------------------
  # * Determine if auto-phoenix can revive summons
  #--------------------------------------------------------------------------
  alias summon_make_phoenix_users_and_targets2 make_phoenix_users_and_targets2
  def make_phoenix_users_and_targets2
    for actor in $game_party.actors
      if actor.summon_id != nil
        t = $game_party.game_summons[actor.summon_id].type
        if t==1
          if not USE_ITEMS_ON_TYPE_1
            @phoenix_targets.delete(actor)
          end
        elsif t==2
          if not USE_ITEMS_ON_TYPE_2
            @phoenix_targets.delete(actor)
          end
        end
      end
    end
    # original call
    summon_make_phoenix_users_and_targets2
  end
end

#==============================================================================
# ? GAME BATTLER
#==============================================================================
class Game_Battler
  #--------------------------------------------------------------------------
  # * Determine if the item can be used on summons
  #--------------------------------------------------------------------------
  alias summons_item_effect item_effect
  def item_effect(item)
    if self.summon_id != nil
      t = $game_party.game_summons[self.summon_id].type
      if t==1
        if not USE_ITEMS_ON_TYPE_1
          return false
        end
      elsif t==2
        if not USE_ITEMS_ON_TYPE_2
          return false
        end
      end
    end
    # original call
    return summons_item_effect(item)
  end
end

#==============================================================================
# ? SCENE SUMMONS
#==============================================================================

class Scene_Summons
  def initialize(menu_index = 0)
    @actors=$game_party.aeons
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make aeons window
    s=[]
    for aeon in @actors
      s.push(aeon.name)
    end
    # No Aeons yet
    if s.size == 0
      @empty = true
      s.push("empty")
      @empty_window = Window_Command.new(120,s)
      @empty_window.x = 260
      @empty_window.y = 208
      @empty_window.active = true
    else
      @empty = false
      @aeons_window = Window_CommandSliding.new(160, s)
      @aeons_window.set_y(64)
      @aeons_window.index = @menu_index
      @aeons_window.active=true
      # Make status window
      @status_window = Window_SummonStatus.new(@actors[0])
      # Make abilities window
      @abilities_window = Window_AbilitiesSliding.new(640+32,64,380,416-96,
        @actors[@menu_index])
      @abilities_window.index = 0
      @abilities_window.active = false
      # Make help window
      @help_window = Window_Help.new
      @help_window.set_text("Select Actor")
      # Associate help window
      @abilities_window.help_window = @help_window
      # Make ItemNeeded Window
      @item_needed_window = Window_ItemNeeded.new
      # Make Confirm Window
      @confirm_window=Window_Confirm.new
      @confirm_window.active = false
      @confirm_window.visible = false
    end    
    # Execute transition
    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
    # Dispose of windows
    if @empty
      @empty_window.dispose
      return
    end
    @aeons_window.dispose
    @status_window.dispose
    @abilities_window.dispose
    @help_window.dispose
    @item_needed_window.dispose
    @confirm_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # No Aeons yet
    if @empty == true
      update_empty
      return
    end
    # Update windows
    @aeons_window.update
    @status_window.update
    @abilities_window.update
    @item_needed_window.update
    @confirm_window.update
    # If aeons window is active: call update_aeons
    if @aeons_window.active
      update_aeons
      return
    end
    # If abilities window is active: call update_abilities
    if @abilities_window.active
      update_abilities
      return
    end
    # If confirm_window is active
    if @confirm_window.active
      update_confirm
      return
    end

  end
  #--------------------------------------------------------------------------
  # * Frame Update (when aeons window is active)
  #--------------------------------------------------------------------------
  def update_aeons
    old_menu_index=@menu_index
    @menu_index=@aeons_window.index
    @status_window.actor=@actors[@menu_index]
    # If UP or DOWN button was pressed
    if Input.trigger?(Input::UP) or Input.trigger?(Input::DOWN) or old_menu_index!=@menu_index
      @status_window.refresh
      @abilities_window.index = 0
      return
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Menu.new
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      @aeons_window.active = false
      @abilities_window.actor = @actors[@menu_index]
      @abilities_window.refresh      
      @abilities_window.active = true      
      @aeons_window.target_x = -160
      @status_window.target_x = 0
      @abilities_window.target_x = 260
      @abilities_window.update_help
      @item_needed_window.target_x = 260
      @item_needed_window.skill = @abilities_window.skill
      @item_needed_window.refresh
      return
    end
  end
  
  def update_abilities
    # If C button was pressed
    if Input.trigger?(Input::C)
      if @actors[@menu_index].summon_skill_can_learn?(
        @abilities_window.skill.id)
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        @confirm_window.visible = true
        @confirm_window.active = true
        @abilities_window.active = false
        return
      else
        # Play cancel SE
        $game_system.se_play($data_system.cancel_se)
        return
      end
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      @aeons_window.active = true
      @abilities_window.active = false      
      @aeons_window.target_x = 0
      @status_window.target_x = 160
      @abilities_window.target_x = 640 +32
      @item_needed_window.target_x = 640 +32
      @help_window.set_text("Select Aeon")
      return
    end
    # If UP or DOWN button was pressed
    if Input.trigger?(Input::UP) or Input.trigger?(Input::DOWN)
      @abilities_window.update_help
      @item_needed_window.skill = @abilities_window.skill
      @item_needed_window.refresh
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # * Frame Update (when confirm window is active)
  #--------------------------------------------------------------------------  
  def update_confirm
    if Input.trigger?(Input::C)
      if @confirm_window.index==0
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        @confirm_window.active=false
        @confirm_window.visible=false
        @abilities_window.active = true
        @actors[@menu_index].learn_skill(@abilities_window.skill.id)
        $game_party.lose_item(AEONS_LEARNINGS[@abilities_window.skill.id][0],
          AEONS_LEARNINGS[@abilities_window.skill.id][1])
        @item_needed_window.refresh
        @abilities_window.refresh
        return
      else
        # Play cancel SE
        $game_system.se_play($data_system.cancel_se)
        @confirm_window.active=false
        @confirm_window.visible=false
        @abilities_window.active = true      
        return
      end
    end
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      @confirm_window.active=false
      @confirm_window.visible=false
      @abilities_window.active = true      
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when empty window is active)
  #--------------------------------------------------------------------------  
  def update_empty
    if Input.trigger?(Input::C)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # Switch to map screen
      $scene = Scene_Menu.new
      return
    end
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Menu.new
      return
    end
  end
end

#==============================================================================
# ? Window_SummonStatus
#==============================================================================
class Window_SummonStatus < Window_Base
  #--------------------------------------------------------------------------
  attr_accessor :actor
  attr_accessor :target_x
  attr_accessor :target_y

  def initialize(actor)
    super(160, 64, 260, 416)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.size = 14
    self.back_opacity = 255
    self.opacity = 255
    @actor = actor
    @target_x=self.x
    @target_y=self.y
    refresh
  end
  
  def set_x(val)
    self.x=val
    @target_x=val
  end
  
  def set_y(val)
    self.y=val
    @target_y=val
  end
  
  def update
    super
    self.x+=0.3*(@target_x-self.x)
    self.y+=0.3*(@target_y-self.y)
  end
  
  def refresh
      self.contents.clear
      x = 16
      y = 0
      actor = @actor
      self.contents.font.size = 24
      self.contents.font.bold = true
      draw_actor_name_bordered(actor, x, y, self.contents.font.size)
      x = 0
      y += self.contents.font.size + 2
      self.contents.font.bold = false
      draw_actor_face(actor, x, y, 80)
      x = 84
      self.contents.font.size=20
      draw_actor_class_2(actor, x, y, 200)
      y += 22
      @level_string_size = 32
      @level_value_size = 84
      @exp_string_size = 32
      self.contents.font.bold = true
      draw_actor_level_2(actor, x, y)
      y += 22
      self.contents.font.size=16
      draw_actor_exp_only(actor, x, y)
      y += 18
      draw_actor_next_exp(actor, x, y)
      
      x=0
      y+=18
      y+=8
      @hp_sp_size=32
      @hp_sp_n1_size=64
      @hp_sp_n2_size=64
      
      draw_actor_hp_4(actor, x, y)
      y+=18
      draw_actor_sp_4(actor, x, y)
      
      y+=18
      self.contents.font.size=14
      
      para_name_space=32
      para_value_space=72
      add_space=44
      bar_space=40
      overlap_bar=70
      
      bar1=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*0,bar_space,12,self.contents)
      bar1.refresh(actor.str,999)
      bar2=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*1,bar_space,12,self.contents)
      bar2.refresh(actor.int,999)
      bar3=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*2,bar_space,12,self.contents)
      bar3.refresh(actor.dex,999)
      bar4=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*3,bar_space,12,self.contents)
      bar4.refresh(actor.agi,999)
      self.contents.font.color=system_color
      self.contents.draw_text(x,y+12*0,para_name_space,12,"Str")
      self.contents.draw_text(x,y+12*1,para_name_space,12,"Mind")
      self.contents.draw_text(x,y+12*2,para_name_space,12,"Hit")
      self.contents.draw_text(x,y+12*3,para_name_space,12,"Spd")
      self.contents.font.color=normal_color
      self.contents.draw_text_bordered(x+para_name_space,y+12*0,para_value_space,12,actor.str.to_s,2)
      self.contents.draw_text_bordered(x+para_name_space,y+12*1,para_value_space,12,actor.int.to_s,2)
      self.contents.draw_text_bordered(x+para_name_space,y+12*2,para_value_space,12,actor.dex.to_s,2)
      self.contents.draw_text_bordered(x+para_name_space,y+12*3,para_value_space,12,actor.agi.to_s,2)
    
      
      x+=para_name_space+para_value_space+bar_space-overlap_bar+add_space

      bar1=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*0,bar_space,12,self.contents)
      bar1.refresh(actor.atk,999)
      bar2=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*1,bar_space,12,self.contents)
      bar2.refresh(actor.pdef,999)
      bar3=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*2,bar_space,12,self.contents)
      bar3.refresh(actor.mdef,999)
      bar4=Bar.new(x+para_name_space+para_value_space-overlap_bar,y+12*3,bar_space,12,self.contents)
      bar4.refresh(actor.eva,999)
      self.contents.font.color=system_color
      self.contents.draw_text(x,y+12*0,para_name_space,12,"Att")
      self.contents.draw_text(x,y+12*1,para_name_space,12,"PDef")
      self.contents.draw_text(x,y+12*2,para_name_space,12,"MDef")
      self.contents.draw_text(x,y+12*3,para_name_space,12,"Eva")
      self.contents.font.color=normal_color
      self.contents.draw_text_bordered(x+para_name_space,y+12*0,para_value_space,12,actor.atk.to_s,2)
      self.contents.draw_text_bordered(x+para_name_space,y+12*1,para_value_space,12,actor.pdef.to_s,2)
      self.contents.draw_text_bordered(x+para_name_space,y+12*2,para_value_space,12,actor.mdef.to_s,2)
      self.contents.draw_text_bordered(x+para_name_space,y+12*3,para_value_space,12,actor.eva.to_s,2)
      
      x=0
      y+=60
      self.contents.font.color = system_color
      self.contents.font.size=14

      self.contents.draw_text(4, y, 48, 32, $data_system.words.weapon)
      self.contents.draw_text(4, y+32, 48, 32, $data_system.words.armor1)
      self.contents.draw_text(4, y+64, 48, 32, $data_system.words.armor2)
      self.contents.draw_text(4, y+96, 48, 32, $data_system.words.armor3)
      self.contents.draw_text(5, y+128, 48, 32, $data_system.words.armor4)

      self.contents.font.color = normal_color
      self.contents.font.bold=false
      self.contents.font.size=20
      x += 54
      
      draw_item_name($data_weapons[@actor.weapon_id], x, y)
      y+=32
      draw_item_name($data_armors[@actor.armor1_id], x, y)
      y+=32
      draw_item_name($data_armors[@actor.armor2_id], x , y)
      y+=32
      draw_item_name($data_armors[@actor.armor3_id], x, y)
      y+=32
      draw_item_name($data_armors[@actor.armor4_id], x , y)

      return
  end
end

#==============================================================================
# ? Window_CommandSliding
#==============================================================================
class Window_CommandSliding < Window_Command
  attr_accessor :target_x
  attr_accessor :target_y
  def initialize(width, commands)
    super(width, commands)
    @target_x=self.x
    @target_y=self.y
  end
  
  def set_x(val)
    self.x=val
    @target_x=val
  end
  
  def set_y(val)
    self.y=val
    @target_y=val
  end
  
  def update
    super
    self.x+=0.3*(@target_x-self.x)
    self.y+=0.3*(@target_y-self.y)
  end
end

#==============================================================================
# ? Window_AbilitiesSliding
#==============================================================================
class Window_AbilitiesSliding < Window_Selectable_Plus
  attr_accessor :target_x
  attr_accessor :target_y
  attr_accessor :actor

  def initialize(x, y, width, height, actor)
    super(x, y, width, height, 22)
    @actor = actor
    @target_x=self.x
    @target_y=self.y
    refresh
  end

  #--------------------------------------------------------------------------
  # * Set coordinates
  #--------------------------------------------------------------------------
  def set_x(val)
    self.x=val
    @target_x=val
  end
  
  def set_y(val)
    self.y=val
    @target_y=val
  end
  
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  # Not needed as WindowSelectablePlus already supports sliding
  #def update
  #  super
  #  self.x+=0.3*(@target_x-self.x)
  #  self.y+=0.3*(@target_y-self.y)
  #end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 0...@actor.skills.size
      skill = $data_skills[@actor.skills[i]]
      if skill != nil
        @data.push(skill)
      end
    end
    keys=AEONS_LEARNINGS.keys
    for key in 0...keys.length
      skill = $data_skills[keys[key]]
      if skill != nil and not @data.include?(skill)
        @data.push(skill)
      end      
    end
    @data.sort! {|a,b|
      a.sp_cost - b.sp_cost }
    # If item count is not 0, make a bit map and draw all items
    @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
  end
  #--------------------------------------------------------------------------
  # * Acquiring Skill
  #--------------------------------------------------------------------------
  def skill
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if @actor.summon_skill_can_learn?(skill.id)
      self.contents.font.color = crisis_color
    elsif @actor.skills.include?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    # initialize values according to window_selectable_plus class
    cursor_width = self.width / @column_max - 32
    x = 4 + index % @column_max * (cursor_width + 32)
    y = index / @column_max * @row_height
    rect = Rect.new(x, y, cursor_width-4, @row_height)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == disabled_color ? 128 : 255
    temp2=Rect.new(x, y, @row_height, @row_height)
    temp1=Rect.new(0, 0, bitmap.width, bitmap.height)
    self.contents.stretch_blt(temp2,bitmap,temp1,opacity)
    self.contents.font.size=@row_height-2
    x = x + @row_height + 4
    self.contents.draw_text(x, y, cursor_width - @row_height - 4 - 4 - 48 - 4, @row_height, skill.name, 0)
    x = x + cursor_width - @row_height - 4 - 4 - 48 - 4
    self.contents.draw_text(x, y, 48, @row_height, skill.sp_cost.to_s, 2)
  end
  #--------------------------------------------------------------------------
  # * Help Text Update
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(self.skill == nil ? "" : self.skill.description)
  end
end

#==============================================================================
# ? Window_ItemNeeded
#==============================================================================
class Window_ItemNeeded < Window_Base
  attr_accessor :target_x
  attr_accessor :target_y
  attr_accessor :skill
  def initialize
    super(640+32, 480-96, 640-260, 96)
    @skill = nil
    @target_x=self.x
    @target_y=self.y
    refresh
  end

  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    self.contents = Bitmap.new(width - 32, height - 32)
    bitmap = RPG::Cache.picture("item_needed_bg")
    src_rect = Rect.new(0, 0, 32, 32)
    dest_rect = Rect.new(8,32,32,32)
    self.contents.stretch_blt(dest_rect,bitmap,src_rect)
    dest_rect = Rect.new(120,32,32,32)
    self.contents.stretch_blt(dest_rect,bitmap,src_rect)
    bitmap = RPG::Cache.picture("item_needed_arrow")
    dest_rect = Rect.new(48,32,64,32)
    self.contents.stretch_blt(dest_rect,bitmap,src_rect)
    
    if @skill != nil
      if AEONS_LEARNINGS[@skill.id] != nil
        x = 8
        y = 0
        item = $data_items[AEONS_LEARNINGS[@skill.id][0]]
        self.contents.draw_text(x, y, 32, 32,
          (AEONS_LEARNINGS[@skill.id][1]).to_s+"x", 1)
        # draw item
        x = 40
        rect = Rect.new(x, y, 32, 32)
        self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
        bitmap = RPG::Cache.icon(item.icon_name)
        self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
        self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
        self.contents.font.bold = true
        y = 32
        x = 4
        self.contents.font.color = ($game_party.item_number(item.id)-AEONS_LEARNINGS[@skill.id][1]>0) ? normal_color : disabled_color
        self.contents.draw_text(x, y, 32, 32,
          ($game_party.item_number(item.id)).to_s, 1)
        x = 120
        self.contents.draw_text(x, y, 32, 32,
          [($game_party.item_number(item.id)-AEONS_LEARNINGS[@skill.id][1]),0].max.to_s, 1)
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # * Set coordinates
  #--------------------------------------------------------------------------
  def set_x(val)
    self.x=val
    @target_x=val
  end
  
  def set_y(val)
    self.y=val
    @target_y=val
  end
  
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    super
    self.x+=0.3*(@target_x-self.x)
    self.y+=0.3*(@target_y-self.y)
  end  
end

#==============================================================================
# ? Window_Confirm
#==============================================================================
class Window_Confirm < Window_Selectable
  attr_accessor :answer
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize()
    super(100, 200, 440, 96+32)
    @column_max = 2
    @item_max = 2
    @choiches= ["Continue","Cancel"]
    self.z=999
    self.back_opacity=255
    self.opacity=255
    refresh
    self.active = true
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.draw_text(0, 0, 408, 32, "Are you sure?", 1)
    self.contents.draw_text(0, 32, 408, 32, "", 1)
    self.contents.draw_text(16, 64, 172, 32, @choiches[0], 1)
    self.contents.draw_text(16+172+32, 64, 172, 32, @choiches[1], 1)
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  def update_cursor_rect
    # If cursor position is less than 0
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get current row
    row = @index / @column_max
    # If current row is before top row
    if row < self.top_row
      # Scroll so that current row becomes top row
      self.top_row = row
    end
    # If current row is more to back than back row
    if row > self.top_row + (self.page_row_max - 1)
      # Scroll so that current row becomes back row
      self.top_row = row - (self.page_row_max - 1)
    end
    # Calculate cursor width
    cursor_width = 180
    # Calculate cursor coordinates
    x = @index==0 ? 16 : 16+172+32
    y = 64
    # Update cursor rectangle
    self.cursor_rect.set(x, y, cursor_width, 32)
  end  
end

class Scene_Battle
  alias summon_main main
  def main
    @summon_help_window=Window_Summon_Help.new(0,64,332+32,200)
    @summon_help_window.visible=false
    @summon_id=-1
    summon_main
    @summon_help_window.dispose
  end
  
  alias summon_update_phase3_skill_select update_phase3_skill_select
  def update_phase3_skill_select
    summon_update_phase3_skill_select
    if @skill_window==nil or @skill_window.visible==false
      @summon_help_window.visible=false
      @summon_id=-1
      return
    end
    if @skill_window.skill.element_set.include?($game_temp.summon_element_id)
      if @skill_window.skill.id != @summon_id
        @summon_id = @skill_window.skill.id
        @summon_help_window.set_summon(@summon_id)
      end
    else
      @summon_help_window.visible=false
      @summon_id=-1
    end
  end  
end

class Window_Summon_Help < Window_Base
  def set_summon(id)
    @summon_id=id
    @actors_ids=$game_party.game_summons[id].actors_ids
    self.visible=true
    refresh
  end
  
  def refresh
    self.height=32+32*@actors_ids.size
    if self.contents!=nil
      self.contents.dispose
    end
    self.contents = Bitmap.new(width-32, height-32)
    self.contents.font.size=18
    x=0
    y=0
    for id in @actors_ids
      x=0
      aeon = $game_actors[id]
      draw_actor_face_small(aeon,x,y,32)
      x=36
      self.contents.draw_text(x,y,60,32,aeon.name)
      # Level
      @level_string_size = 60
      @level_value_size = 30
      self.contents.font.bold = true
      self.contents.font.size = 12
      fontsize=self.contents.font.size
      self.contents.font.color=Color.new(255,166,27)
      self.contents.draw_text_bordered_2(x, y+20, @level_string_size, fontsize,
        "Lv.", 0)
      self.contents.font.size = 32
      fontsize=self.contents.font.size
      self.contents.draw_text_bordered_2(x + @level_string_size, y+6,
        @level_value_size, fontsize, aeon.level.to_s, 0)
      self.contents.font.size = 18
      self.contents.font.color=Color.new(255,255,255)
      self.contents.font.bold = false
      x=68
      barhp=Bar.new(x+64,y,96,8,self.contents)
      barhp.bar="bar_hp"
      barhp.bar_background="bar_hp_bg"
      barhp.refresh(aeon.hp,aeon.maxhp)
      # 64+24+72
      self.contents.draw_text(x+64,y,24,32,"HP:")
      self.contents.draw_text(x+64+24,y,72,32,aeon.hp.to_s+"/"+
      aeon.maxhp.to_s)
      barsp=Bar.new(x+164,y,96,8,self.contents)
      barsp.bar="bar_sp"
      barsp.bar_background="bar_hp_bg"
      barsp.refresh(aeon.sp,aeon.maxsp)
      self.contents.draw_text(x+164,y,24,32,"SP:")
      self.contents.draw_text(x+164+24,y,72,32,aeon.sp.to_s+"/"+
      aeon.maxsp.to_s)
      y+=32
    end
  end
end

class Game_Actor
    attr_accessor   :original_form_id
    attr_accessor   :transformed_form_id
end

$data_skills.each_index do |index| $retire_skill_id=index if ($data_skills[index]!=nil and $data_skills[index].name==RETIRE_NAME) end  

#==============================================================================
# ? SCENE TRANSFORMATIONS
#==============================================================================

class Scene_Transformations < Scene_Summons
  def initialize(menu_index = 0)
    @actors=$game_party.transformations
    @menu_index = menu_index
  end
  
  #--------------------------------------------------------------------------
  # * Frame Update (when aeons window is active)
  #--------------------------------------------------------------------------
  def update_aeons
    old_menu_index=@menu_index
    @menu_index=@aeons_window.index
    @status_window.actor=@actors[@menu_index]
    # If UP or DOWN button was pressed
    if Input.trigger?(Input::UP) or Input.trigger?(Input::DOWN) or old_menu_index!=@menu_index
      @status_window.refresh
      @abilities_window.index = 0
      return
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Menu.new
      return
    end
  end
end

You have use the "Summon" tag again, like you did.
That error shouldn't be there...

[habs11]

Hey Charlie, thank you for removing those debug messages, much appreciated. Ok, so I still had the error, but I think I might have fixed it.

So take a look at the error line:
715 ((aeon.invoked_during_last_battle)?(INVOKED_AEON_EXP_MULTIPLIER):(NOT_INVOKED_AEON_EXP_[]MULTIPLIER)))

Now for whatever reason, on my script there was a symbol that looks like a square in front of the last Multiplier. I drew it with brackets ([]) above. I don't know what the symbol is, I have never seen it in any other scripts, and it looked out of place so I tried deleting it and it worked! No more error! I guessing that this is not in the original script because I don't see it in the one you posted above. Any ideas where it came from? And is it ok to leave off? There is another one on line 722 right before the last Transformation. I denoted it with the ([]) again. Should I get rid of it?

722 ((transformation.invoked_during_last_battle)?(INVOKED_TRANSFORMATION_EXP_MULTIPLIER):(NOT_INVOKED _[]TRANSFORMATION_EXP_MULTIPLIER)))?

Again I don't see it in the script above here, so I don't know why it would be in the game script when I pasted it into the summons script. I hope this helps. Let me know if I'm messing things up. Sorry that this little problem has taken much of your time. Thanks for the help.

[Charlie Fleed]

I don't know where these "[]" come from... you did right by getting rid of them.
I'm glad to hear everything is working now. Cya.

[Kany64]

charlie i have a problem again when i want to swith a actor in battle

then is writing
script super arts1.7 line351 type error occured
no implicit conversion from nil to integer

[Charlie Fleed]

Make sure you created a skill named with the name defined in:
SWITCH_NAME="Switch"
and that it calls a common event with "$scene.switch()" in it.

[pman6666]

it will not run in my xp it says "project could not read due to incompatibility between software versions"
plz help

[lndignation]

Hey Charlie, I just joined the forums to ask you a question on the "Superarts" section of the script

I've fiddled around with the script a bit, changing the status screen slightly to a different input button and some other small details.

Now, in my game, I would prefer if only one kind Super Arts was available. I assume I would remove the following the lines to prevent toggling and such, but how would I actually remove some of the methods of filling the bar, i.e, I only want the bar to be filled by "rage".

I know I have to get rid of the following code, but I don't know what else. I don't want to accidently delete something I needed :P

Code:

class Scene_Status
  alias sa_update update
  def update
    if Input.trigger?(Input::A)
      @actor.toggle_superart_type
      @status_window.refresh
      return
    end
    sa_update
  end
end

[Charlie Fleed]

@pman6666: I'm not sure but maybe the problem is the dll you have installed in your system. Open Game.ini in the demo folder and locate the line that says Library=RGSS102E.dll, you can change it to reflect the dll you have.

@Indignation: You can just remove that section. The code for the other filling methods will never be executed, you don't need to actually remove it.

[lndignation]

Alright thanks a lot, but how can I set what method of super art filling is default instead of it being the damage inflicted one?

[Charlie Fleed]

Here you decide, it's in the configuration:

Code:

SUPER_ARTS_TYPE_DEFAULT=1
# 0 - Earn SA points by suffered damage (SA=TYPE_0_RATE*SUPER_ARTS_MAX*damage/(MaxHp))
# 1 - Earn SA points by inflicted damage (SA=TYPE_1_RATE*SUPER_ARTS_MAX*damage/(AttackerMaxHP))
# 2 - Earn SA points by suffered damage by allies (SA=TYPE_2_RATE*SUPER_ARTS_MAX*damage/(AllyMaxHp))
# 3 - Earn SA points when skills belonging to given categories are used (SA=TYPE_3_RATE*SUPER_ARTS_MAX)
# 4 - Earn SA points when hp <= max_hp / 4 (SA=TYPE_4_RATE*SUPER_ARTS_MAX)