*Aeon System

[Sleeping Leonhart]

Aeon System

Descrizione

Questo script permette di evocare degli Eoni che sostituiscono il party per tutta la loro permanenza. Se gli Eoni muoiono il Party torna in battaglia.

Autore

The Sleeping Leonhart

Demo

Mirror 1
Mirror 2
Mirror 3
Mirror 4
Mirror 5

Script

Aeon System

 

#==============================================================================
# ** Aeon System
#------------------------------------------------------------------------------
# Autore: The Sleeping Leonhart
# Versione: 3.0
# Data di rilascio: 29/05/2008
#------------------------------------------------------------------------------
# Descrizione:
# Questo script permette di evocare degli Eoni che sostituiscono il party per tutta
# la loro permanenza. Se gli Eoni muoiono il Party torna in battaglia.
#------------------------------------------------------------------------------
# Istruzioni:
# Create delle Skill che serviranno per richiamare gli Eoni.
# Per personalizzare lo script andate nella sezione Configurazione.
#==============================================================================

#==============================================================================
# Configurazione
#==============================================================================

module Aeon_System
#=========================================================================
# Aeon_Skill: Imposta le skill che evocano gli Eoni.
#-------------------------------------------------------------------------
# Sintassi:
# Aeon_Skill = {Skill_ID => [[Actor_ID, ...], Turn, Type],...}
# Parametri:
# Skill_ID: Id della skill nel database
# Actor_ID: Id dell'eroe nel database
# Turn: Numeri di turni in cui l'eone resta in battaglia, se 0 resta fino al ritiro.
# Type: 1:Evoca solo l'Eone;
# 2:Evoca l'eone e l'invocatore;
# 3:Sostituisce l'evocatore con l'eone.
#=========================================================================
Aeon_Skill = {57=>[[3,4],2,1],61=>[[3,4],2,1]}
#=========================================================================
# Return_Skill: Imposta la skill che richiama gli Eoni.
#-------------------------------------------------------------------------
# Sintassi:
# Return_Skill= Skill_ID
# Parametri:
# Skill_ID: Id della skill nel database
#=========================================================================
Return_Skill = 81
#=========================================================================
# Transition: Imposta la transizione visualizzata durante l'evocazione.
#-------------------------------------------------------------------------
# Sintassi:
# Transition = String
# Parametri:
# String: Nome della Transizione
#=========================================================================
Transition = "001-Blind01"
#=========================================================================
# BGM: Imposta la musica eseguita durante i truni dell'evocazione.
#-------------------------------------------------------------------------
# Sintassi:
# BGM = {Skill_ID => String}
# Parametri:
# Skill_ID: Id della skill nel database che richiama l'eone
# String: Nome della musica presente nella cartella BGM, se nil la musica non cambia
#=========================================================================
BGM = {57 => "005-Boss01"}
#=========================================================================
# BGM.default: Imposta la musica per gli Eoni non dichiarati in BGM.
#-------------------------------------------------------------------------
# Sintassi:
# BGM.default = String
# Parametri:
# String: Nome della musica presente nella cartella BGM, se nil la musica non cambia
#=========================================================================
BGM.default = nil
#=========================================================================
# Experience: Imposta se gli Eoni prendono esperienza
#-------------------------------------------------------------------------
# Sintassi:
# Experience = Boolean
# Parametri:
# Boolean: Se true gli Eoni prendono esperienza, altrimenti no
#=========================================================================
Experience = true
end

$tsl_script = [] if $tsl_script == nil
$tsl_script.push("Aeon System")

class Scene_Battle
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
alias tslaeons_scenebattle_main main
def main
@old_party = []
@aeon_turn = 0
@turn_passed = 0
@evocated = false
tslaeons_scenebattle_main
end
#--------------------------------------------------------------------------
# * Determine Battle Win/Loss Results
#--------------------------------------------------------------------------
alias tslaeons_scene_battle_judge judge
def judge
if $game_party.all_dead? and @evocated
call_old_party
end
# Call old Method
tslaeons_scene_battle_judge
end
#--------------------------------------------------------------------------
# * Frame Update (main phase step 6 : refresh)
#--------------------------------------------------------------------------
alias tslaeons_scenebattle_update_phase4_step6 update_phase4_step6
def update_phase4_step6
if @aeon_turn != 0
if ($game_temp.battle_turn - @turn_called) == @aeon_turn and @evocated
call_old_party
end
end
if @active_battler.current_action.kind == 1
a = true
for enemy in $game_troop.enemies
if enemy.exist?
a = false
end
end
call_aeon(@skill.id) if Aeon_System::Aeon_Skill.include?(@skill.id) and a == false
call_old_party if Aeon_System::Return_Skill == @skill.id
end
tslaeons_scenebattle_update_phase4_step6
end
#--------------------------------------------------------------------------
# * Call an Aeon
#--------------------------------------------------------------------------
def call_aeon(skill_id)
@old_party = $game_party.actors.dup
new_party = []
aeon = Aeon_System::Aeon_Skill[skill_id]
for i in aeon[0]
new_party.push($game_actors[i])
$game_actors[i].evocated = true
end
case aeon[2]
when 2
new_party.push($game_actors[@active_battlers.id])
when 3
for actor in $game_party.actors
new_party.push($game_actors[actor.id])
end
new_party.delete($game_actors[@active_battlers.id])
end
if Aeon_System::Transition != nil
Graphics.freeze
$game_temp.transition_processing = true
$game_temp.transition_name = Aeon_System::Transition
end
$game_party.actors = new_party.dup
@aeon_escape = $game_temp.battle_can_escape
$game_temp.battle_can_escape = false
@aeon_turn = aeon[1]
@turn_called = $game_temp.battle_turn
@evocated = true
bgm = Aeon_System::BGM
Audio.bgm_play("Audio/BGM/" + bgm[skill_id], 100, 100) if bgm.include?(skill_id) and bgm[skill_id] != nil
@spriteset.dispose
@spriteset = Spriteset_Battle.new
@status_window.refresh
end
#--------------------------------------------------------------------------
# * Call the old Party
#--------------------------------------------------------------------------
def call_old_party
if Aeon_System::Transition != nil
Graphics.freeze
$game_temp.transition_processing = true
$game_temp.transition_name = Aeon_System::Transition
end
$game_party.actors = @old_party.dup
$game_system.bgm_play($game_system.battle_bgm)
$game_temp.battle_can_escape = @aeon_escape
@spriteset.dispose
@spriteset = Spriteset_Battle.new
@status_window.refresh
@evocated = false
end
#--------------------------------------------------------------------------
# * Start After Battle Phase
#--------------------------------------------------------------------------
alias tslaeons_scenebattle_start_phase5 start_phase5
def start_phase5
if @evocated
call_old_party
end
if Aeon_System::Experience
exp = 0
for enemy in $game_troop.enemies
unless enemy.hidden
exp += enemy.exp
end
end
for i in 1...$data_actors.size
actor = $game_actors[i]
if actor.cant_get_exp? == false
if actor.evocated == true
last_level = actor.level
actor.exp += exp
actor.evocated = false
end
end
end
end
# Call old Method
tslaeons_scenebattle_start_phase5
end
end

class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :evocated
#--------------------------------------------------------------------------
# * Object Initialization
# actor_id : actor ID
#--------------------------------------------------------------------------
alias tslaeons_game_actor_initialize initialize
def initialize(actor_id)
super()
@evocated = false
# Call old Method
tslaeons_game_actor_initialize(actor_id)
end
end

class Game_Party
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :actors # actors
end

 

Script Evocazioni - XRXS_BP Version

 

#===============================================================================
# Summon
#=============================================================================
# The Sleeping Leonhart
# Versione XRXS_BP
# 9-11-2007
#=============================================================================
# Lo script permette di evocare come in Final Fantasy X.
# L'evocazione è un comune eroe che va creato ne database.
# La skill con cui si richiama l'evocazione può essere impostata come una normale
# skill.
#=============================================================================
module Evocation
#Sintassi:
#Evocated_Actor = {Id della Skill => [id Eroe Evocato1,Id Eroe Evocato2,etc..] }
Evocated_Actor = {81 => [3,4], 57 =>[5,6], 61 => [9]}

#Sintassi:
#Summon_Item = {ID Oggetto => ID Skill}
#L'oggetto richiama l'id della skill e la usa
#le proprita di quella skill (Turni, BGM, ecc..)
Summon_Item = {1 => 81}

#Id della skill che rimuove solo l'evocatore
Remove_Only_Summoner = {61 => true}
Remove_Only_Summoner.default = false

#Id della skill per far rimanere solo l'evocatore e l'evocazione
Summoner_Rest = {81 => true}
Summoner_Rest.default = false

#Id della skill per far rientrare l'evocazione
Return_Id = 83

#Name della transizione
Transition = "001-Blind01"

#Sintassi:
#BGM = {Id della Skill => Nome del BGM}
BGM = {81 => "005-Boss01"}
#BGM per le summon non dichiarate
BGM.default = nil

#Sintassi:
#Turn = {Id della Skill => Numero di Turni}
#0 = Infiniti
Turn = {81 => 0}
Turn.default = 0

#Se è true la summon riceve esperieza(la stessa del party)
Experience = false
end
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles the actor. It's used within the Game_Actors class
# ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
attr_accessor :evocated
# Aliasing old Method
alias tsl_evocation_game_actor_initialize initialize
#--------------------------------------------------------------------------
# * Object Initialization
# actor_id : actor ID
#--------------------------------------------------------------------------
def initialize(actor_id)
super()
@evocated = false
# Call old Method
tsl_evocation_game_actor_initialize(actor_id)
end
end

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================
class Scene_Battle
# Aliasing old Method
alias tsl_evocation_scene_battle_main main
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
@last_party = []
@evocation = false
@evocated_turn = 0
@summon = []
# Call old Method
tsl_evocation_scene_battle_main
end

# Aliasing old Method
alias tsl_evocation_scene_battle_judge judge
#--------------------------------------------------------------------------
# * Determine Battle Win/Loss Results
#--------------------------------------------------------------------------
def judge
if @evocation == true
if $game_party.all_dead?
party_return
end
if @summon != []
if summon_dead?
party_return
end
end
end
# Call old Method
tsl_evocation_scene_battle_judge
end
def summon_dead?
if @summon.size == 0
return false
end
for actor in @summon
if actor.hp > 0
return false
end
end
return true
end
# Aliasing old Method
alias tsl_evocation_scene_battle_update_phase4_step5 update_phase4_step5
def update_phase4_step5
evocated?
# Call old Method
tsl_evocation_scene_battle_update_phase4_step5
end
#--------------------------------------------------------------------------
# * Determine if Summon or recall Party
#--------------------------------------------------------------------------
def evocated?
if Evocation::Summon_Item.include?(@item.id)
@id = Evocation::Summon_Item[@item.id]
else
@id = @skill.id
end
if Evocation::Evocated_Actor.include?(@id)
if Evocation::BGM.include?(@id)
if Evocation::BGM != nil
Audio.bgm_play("Audio/BGM/" + Evocation::BGM[@id], 100, 100)
$game_system.bgm_memorize
end
end
@summon_turn = Evocation::Turn[@id]
@evocated_turn = $game_temp.battle_turn
evocate_actor(Evocation::Evocated_Actor[@id])
end
if @id == Evocation::Return_Id
party_return
end
end
#--------------------------------------------------------------------------
# * Call the summon
#--------------------------------------------------------------------------
def evocate_actor(actors)
#Memorize the old party
unless @evocation == true
for i in 0..$game_party.actors.size - 1
@last_party[i] = $game_party.actors[i].id
end
end
#Change Escape Condition
@escape = $game_temp.battle_can_escape
$game_temp.battle_can_escape = false
#Clear the party
if Evocation::Remove_Only_Summoner[@id]
$game_party.remove_actor(@active_battler.id)
else
$game_party.actors.clear
end
#Execute the transition
if Evocation::Transition != nil
Graphics.freeze
$game_temp.transition_processing = true
$game_temp.transition_name = Evocation::Transition
end
#Summon the actor
if Evocation::Remove_Only_Summoner[@id]
for i in 0..actors.size - 1
$game_party.add_actor(actors[i])
@summon[i] = $game_actors[actors[i]]
$game_actors[actors[i]].evocated = true
end
else
if Evocation::Summoner_Rest[@id]
$game_party.add_actor(@active_battler.id)
end
for i in 0..actors.size - 1
$game_party.add_actor(actors[i])
$game_actors[actors[i]].evocated = true
end
end
@cp_thread = Scene_Battle_CP.new
#Set the value of variable
@evocation = true
@spriteset.dispose
@spriteset = Spriteset_Battle.new
@status_window.refresh
@skill = nil
@item = nil
end
#--------------------------------------------------------------------------
# * Recall old Party
#--------------------------------------------------------------------------
def party_return
$game_system.bgm_play($game_system.bgm_memorize)
$game_party.actors.clear
if Evocation::Transition != nil
Graphics.freeze
$game_temp.transition_processing = true
$game_temp.transition_name = Evocation::Transition
end
$game_temp.battle_can_escape = @escape
for i in 0..@last_party.size - 1
$game_party.add_actor(@last_party[i])
end
@spriteset.dispose
@spriteset = Spriteset_Battle.new
@cp_thread = Scene_Battle_CP.new
@status_window.refresh
@summon_turn = 0
@evocation = false
@summon = []
@skill = nil
@item = nil
end

# Aliasing old Method
alias tsl_evocation_scene_battle_update_phase4_step6 update_phase4_step6
#--------------------------------------------------------------------------
# * Frame Update (main phase step 6 : refresh)
#--------------------------------------------------------------------------
def update_phase4_step6
if @summon_turn != 0
if ($game_temp.battle_turn - @evocated_turn) == @summon_turn and @evocation
party_return
end
end
# Call old Method
tsl_evocation_scene_battle_update_phase4_step6
end

# Aliasing old Method
alias tsl_evocation_scene_battle_start_phase5 start_phase5
#--------------------------------------------------------------------------
# * Start After Battle Phase
#--------------------------------------------------------------------------
def start_phase5
if @evocation
party_return
end
if Evocation::Experience
exp = 0
for enemy in $game_troop.enemies
unless enemy.hidden
exp += enemy.exp
end
end
for i in 1...$data_actors.size
actor = $game_actors[i]
if actor.cant_get_exp? == false
if actor.evocated == true
last_level = actor.level
actor.exp += exp
actor.evocated = false
end
end
end
end
# Call old Method
tsl_evocation_scene_battle_start_phase5
end
end 

 

 

Aeon System RTAB Version

 

 

#==============================================================================
# ** Aeon System RTAB Version
#------------------------------------------------------------------------------
# Autore: The Sleeping Leonhart
# Versione: 3.0
# Data di rilascio: 30/05/2008
#------------------------------------------------------------------------------
# Descrizione:
# Questo script permette di evocare degli Eoni che sostituiscono il party
# per tutta la loro permanenza. Se un Eone muore il Party torna in battaglia.
#------------------------------------------------------------------------------
# Istruzioni:
# Create delle Skill che serviranno per richiamare gli Eoni.
# Per personalizzare lo script andate nella sezione Configurazione.
#==============================================================================

#==============================================================================
# Configurazione
#==============================================================================

module Aeon_System
#=========================================================================
# Aeon_Skill: Imposta le skill che evocano gli Eoni.
#-------------------------------------------------------------------------
# Sintassi:
# Aeon_Skill = {Skill_ID => [[Actor_ID, ...], Turn, Type],...}
# Parametri:
# Skill_ID: Id della skill nel database
# Actor_ID: Id dell'eroe nel database
# Turn: Numeri di turni in cui l'eone resta in battaglia, se 0 resta fino al ritiro.
# Type: 1:Evoca solo l'Eone;
# 2:Evoca l'eone e l'invocatore;
# 3:Sostituisce l'evocatore con l'eone.
#=========================================================================
Aeon_Skill = {57=>[[3,4],2,1],61=>[[3,4],2,1]}
#=========================================================================
# Return_Skill: Imposta la skill che richiama gli Eoni.
#-------------------------------------------------------------------------
# Sintassi:
# Return_Skill= Skill_ID
# Parametri:
# Skill_ID: Id della skill nel database
#=========================================================================
Return_Skill = 81
#=========================================================================
# Transition: Imposta la transizione visualizzata durante l'evocazione.
#-------------------------------------------------------------------------
# Sintassi:
# Transition = String
# Parametri:
# String: Nome della Transizione
#=========================================================================
Transition = "001-Blind01"
#=========================================================================
# BGM: Imposta la musica eseguita durante i truni dell'evocazione.
#-------------------------------------------------------------------------
# Sintassi:
# BGM = {Skill_ID => String}
# Parametri:
# Skill_ID: Id della skill nel database che richiama l'eone
# String: Nome della musica presente nella cartella BGM, se nil la musica non cambia
#=========================================================================
BGM = {57 => "005-Boss01"}
#=========================================================================
# BGM.default: Imposta la musica per gli Eoni non dichiarati in BGM.
#-------------------------------------------------------------------------
# Sintassi:
# BGM.default = String
# Parametri:
# String: Nome della musica presente nella cartella BGM, se nil la musica non cambia
#=========================================================================
BGM.default = nil
#=========================================================================
# Experience: Imposta se gli Eoni prendono esperienza
#-------------------------------------------------------------------------
# Sintassi:
# Experience = Boolean
# Parametri:
# Boolean: Se true gli Eoni prendono esperienza, altrimenti no
#=========================================================================
Experience = true
end

$tsl_script = [] if $tsl_script == nil
$tsl_script.push("Aeon System")

class Scene_Battle
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
alias tslaeons_scenebattle_main main
def main
@old_party = []
@aeon_turn = 0
@turn_passed = 0
@evocated = false
tslaeons_scenebattle_main
end
#--------------------------------------------------------------------------
# * Determine Battle Win/Loss Results
#--------------------------------------------------------------------------
alias tslaeons_scene_battle_judge judge
def judge
if $game_party.all_dead? and @evocated
call_old_party
end
# Call old Method
tslaeons_scene_battle_judge
end
#--------------------------------------------------------------------------
# * Frame Update (main phase step 6 : refresh)
#--------------------------------------------------------------------------
alias tslaeons_scenebattle_update_phase4_step6 update_phase4_step6
def update_phase4_step6(battler)
if @aeon_turn != 0
if ($game_temp.battle_turn - @turn_called) == @aeon_turn and @evocated
call_old_party
end
end
if battler.current_action.kind == 1
a = true
for enemy in $game_troop.enemies
if enemy.exist?
a = false
end
end
call_aeon(@skill.id) if Aeon_System::Aeon_Skill.include?(@skill.id) and a == false
call_old_party if Aeon_System::Return_Skill == @skill.id
end
tslaeons_scenebattle_update_phase4_step6(battler)
end
#--------------------------------------------------------------------------
# * Call an Aeon
#--------------------------------------------------------------------------
def call_aeon(skill_id)
refresh_aeons_party
@status_window.dispose
@old_party = $game_party.actors.dup
new_party = []
aeon = Aeon_System::Aeon_Skill[skill_id]
for i in aeon[0]
new_party.push($game_actors[i])
end
case aeon[2]
when 2
new_party.push($game_actors[@active_battlers.id])
when 3
for actor in $game_party.actors
new_party.push($game_actors[actor.id])
end
new_party.delete($game_actors[@active_battlers.id])
end
if Aeon_System::Transition != nil
Graphics.freeze
$game_temp.transition_processing = true
$game_temp.transition_name = Aeon_System::Transition
end
$game_party.actors = new_party.dup
refresh_aeons_party
@aeon_escape = $game_temp.battle_can_escape
$game_temp.battle_can_escape = false
@aeon_turn = aeon[1]
@turn_called = $game_temp.battle_turn
@evocated = true
bgm = Aeon_System::BGM
Audio.bgm_play("Audio/BGM/" + bgm[skill_id], 100, 100) if bgm.include?(skill_id) and bgm[skill_id] != nil
@spriteset.dispose
@spriteset = Spriteset_Battle.new
@status_window = Window_BattleStatus.new
@command.clear
end
#--------------------------------------------------------------------------
# * Refresh the Party
#--------------------------------------------------------------------------
def refresh_aeons_party
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
command_delete
actor.at = 0
actor.atp = 0
$scene.spell_reset(actor)
actor.damage_pop = {}
actor.damage = {}
actor.damage_sp = {}
actor.critical = {}
actor.recover_hp = {}
actor.recover_sp = {}
actor.state_p = {}
actor.state_m = {}
actor.animation = []
actor.current_action.clear
end
end
#--------------------------------------------------------------------------
# * Call the old Party
#--------------------------------------------------------------------------
def call_old_party
@status_window.dispose
if Aeon_System::Transition != nil
Graphics.freeze
$game_temp.transition_processing = true
$game_temp.transition_name = Aeon_System::Transition
end
$game_party.actors = @old_party.dup
$game_system.bgm_play($game_system.battle_bgm)
$game_temp.battle_can_escape = @aeon_escape
@spriteset.dispose
@spriteset = Spriteset_Battle.new
@status_window = Window_BattleStatus.new
@evocated = false
end
#--------------------------------------------------------------------------
# * Start After Battle Phase
#--------------------------------------------------------------------------
alias tslaeons_scenebattle_start_phase5 start_phase5
def start_phase5
if @evocated
call_old_party
end
if Aeon_System::Experience
exp = 0
for enemy in $game_troop.enemies
unless enemy.hidden
exp += enemy.exp
end
end
for i in 1...$data_actors.size
actor = $game_actors[i]
if actor.cant_get_exp? == false
if actor.evocated == true
last_level = actor.level
actor.exp += exp
actor.evocated = false
end
end
end
end
# Call old Method
tslaeons_scenebattle_start_phase5
end
end

class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :evocated
#--------------------------------------------------------------------------
# * Object Initialization
# actor_id : actor ID
#--------------------------------------------------------------------------
alias tslaeons_game_actor_initialize initialize
def initialize(actor_id)
super()
@evocated = false
# Call old Method
tslaeons_game_actor_initialize(actor_id)
end
end

class Game_Party
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :actors # actors
end

class Window_BattleStatus < Window_Base
alias tsl_evocation_windowbattlestatus_refresh refresh
def refresh(number = 0)
if number == nil
number = 0
end
tsl_evocation_windowbattlestatus_refresh(number = 0)
end
alias tsl_evocation_windowbattlestatus_atrefresh at_refresh
def at_refresh(number = 0)
if number == nil
number = 0
end
tsl_evocation_windowbattlestatus_atrefresh(number = 0)
end
end  

Aeon Development

 

#==============================================================================
# ** Aeon Development
#------------------------------------------------------------------------------
# Autore: The Sleeping Leonhart
# Versione: 2.0
# Data di rilascio: 29/05/2008
#------------------------------------------------------------------------------
# Descrizione:
# Questo script permette di visualizzare lo status degli Eoni e di fargli
# apprendere nuove abilità, potenziare le statistiche e usare oggetti.
#------------------------------------------------------------------------------
# Istruzioni:
# Per richiamare il menu dello status inserire il seguente codice
# attraverso il comando Script degli eventi:
# $scene = Scene_AeonStatus.new
# Per personalizzare lo script andate nella sezione Configurazione.
#==============================================================================

#==============================================================================
# Configurazione
#==============================================================================
module Aeon_Development
#=========================================================================
# Aeon_Item_Id: Imposta gli oggetti usabili dagli Eoni.
#-------------------------------------------------------------------------
# Sintassi:
# Aeon_Item_Id = [item_ID, ...]
# Parametri:
# Item_ID: Id dell'oggetto nel database
#=========================================================================
Aeon_Item_Id = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22]
#=========================================================================
# Stat_Item: Imposta gli oggetti che aumentano le statistiche.
#-------------------------------------------------------------------------
# Sintassi:
# Attributo_Item = {Item_ID => [N1, N2],...}
# Parametri:
# Item_ID: Id dell'oggetto nel database
# N1: Incremento della statistica
# N2: Quantità di ogetti richiesta
#=========================================================================
Hp_Item = {1=>[500,2]}
Sp_Item = {2=>[40,1]}
Atk_Item = {3=>[5,2]}
Str_Item = {4=>[5,5]}
PDef_Item = {5=>[5,5]}
MDef_Item = {6=>[5,5]}
Agi_Item = {7=>[5,5]}
Int_Item = {8=>[5,5]}
Dex_Item = {9=>[5,5]}
Eva_Item = {10=>[1,99]}
#=========================================================================
# Skill_Item: Imposta gli oggetti che insegnano le skill.
#-------------------------------------------------------------------------
# Sintassi:
# Skill_Item = {Item_ID => [skill_ID, N2],...}
# Parametri:
# Item_ID: Id dell'oggetto nel database
# Skill_ID: Id della skill nel database che verrà appresa
# N2: Quantità di ogetti richiesta
#=========================================================================
Skill_Item = {1=>[10,5],3=>[25,7]}
end

$tsl_script = [] if $tsl_script == nil
$tsl_script.push("Aeon Development")

#Controlla l'esistenza degli script richiesti
if $tsl_script.include?("Aeon System")
class Game_Battler
attr_accessor :atks
attr_accessor :pdefs
attr_accessor :mdefs
attr_accessor :evas
alias tslaeonsdevelop_gamebattler_initialize initialize
def initialize
@atks = 0
@pdefs = 0
@mdefs = 0
@evas = 0
tslaeonsdevelop_gamebattler_initialize
end
alias tslaeonsdevelop_gamebattler_atk atk
def atk
value = tslaeonsdevelop_gamebattler_atk
value += @atks
return value
end
alias tslaeonsdevelop_gamebattler_pdef pdef
def pdef
value = tslaeonsdevelop_gamebattler_pdef
value += @pdefs
return value
end
alias tslaeonsdevelop_gamebattler_mdef mdef
def mdef
value = tslaeonsdevelop_gamebattler_mdef
value += @mdefs
return value
end
alias tslaeonsdevelop_gamebattler_eva eva
def eva
value = tslaeonsdevelop_gamebattler_eva
value += @evas
return value
end
end

class Window_AeonStatus < Window_Base
def initialize(actor)
super(160, 64, 480, 416)
self.contents = Bitmap.new(width - 32, height - 32)
@actor = $game_actors[actor]
refresh
end
def refresh
self.contents.clear
draw_actor_graphic(@actor, 40, 112)
draw_actor_name(@actor, 4, 0)
draw_actor_class(@actor, 4 + 144, 0)
draw_actor_level(@actor, 96, 32)
draw_actor_state(@actor, 96, 64)
draw_actor_hp(@actor, 96, 112, 172)
draw_actor_sp(@actor, 96, 144, 172)
draw_actor_parameter(@actor, 0, 192, 0)
draw_actor_parameter(@actor, 0, 224, 1)
draw_actor_parameter(@actor, 0, 256, 2)
draw_actor_parameter(@actor, 0, 288, 3)
draw_actor_parameter(@actor, 256, 192, 4)
draw_actor_parameter(@actor, 256, 224, 5)
draw_actor_parameter(@actor, 256, 256, 6)
self.contents.font.color = system_color
self.contents.draw_text(256, 288, 120, 32, "Evasione")
self.contents.font.color = normal_color
self.contents.draw_text(256 + 120, 288, 36, 32, @actor.eva.to_s, 2)
self.contents.font.color = system_color
self.contents.draw_text(256, 48, 80, 32, "Exp")
self.contents.draw_text(256, 80, 80, 32, "Next")
self.contents.font.color = normal_color
self.contents.draw_text(256 + 80, 48, 84, 32, @actor.exp_s, 2)
self.contents.draw_text(256 + 80, 80, 84, 32, @actor.next_rest_exp_s, 2)
end
end

class Window_AeonCommand < Window_Selectable
def initialize
super(0, 64, 160, 416)
self.contents = Bitmap.new(width - 32, @item_max * 32)
@learned = []
@command = []
$aeons_party = []
refresh
self.index = 0

end
def refresh
self.contents.clear
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
for j in actor.skills
if Aeon_System::Aeon_Skill.include?(j) and not @learned.include?(j)
@learned.push(j)
end
end
end
for i in 0...@learned.size
for j in 0...Aeon_System::Aeon_Skill[@learned[i]][0].size
@command.push(Aeon_System::Aeon_Skill[@learned[i]][0][j]) if not @command.include?(Aeon_System::Aeon_Skill[@learned[i]][0][j])
end
end
@item_max = [@command.size,1].max
self.contents = Bitmap.new(width - 32, @item_max * 32)
for i in 0..@command.size - 1
$aeons_party[i] = @command[i]
draw_item(i)
end
end
def actor
return @command[self.index]
end
def draw_item(index)
x = 4
y = index * 32
self.contents.draw_text(x, y, 160, 32, $data_actors[@command[index]].name)
end
def update_cursor_rect
if self.index == -1
self.cursor_rect.set(0, 0, 128, @item_max * 32)
else
self.cursor_rect.set(0, @index * 32, 128, 32)
end
end
end

class Window_AeonChoice < Window_Selectable
def initialize
super(0, 0, 640, 64)
self.contents = Bitmap.new(width - 32, height - 32)
@commands = ["Oggetti","Addestra","Alleva"]
@item_max = 3
@column_max = 3
draw_item(0, normal_color)
draw_item(1, normal_color)
draw_item(2, normal_color)
self.active = false
self.index = 0
end

def draw_item(index, color)
self.contents.font.color = color
rect = Rect.new(index * 160 + 84, 0, 128 - 10, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[index], 1)
end

def update_cursor_rect
self.cursor_rect.set(index * 160+80, 0, 128, 32)
end
end

class Window_Aeon_Item < Window_Selectable
def initialize
super(160, 64, 480, 416)
@column_max = 1
refresh
self.index = 0
if $game_temp.in_battle
self.y = 64
self.height = 272
self.back_opacity = 160
end
end
def item
return @data[self.index]
end
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
@data = []
for i in 1...$data_items.size
if $game_party.item_number(i) > 0
for j in 0...Aeon_Development::Aeon_Item_Id.size
if i == Aeon_Development::Aeon_Item_Id[j]
@data.push($data_items [i] )
end
end
end
end
@item_max = @data.size
if @item_max > 0
self.contents = Bitmap.new(width - 32, row_max * 32)
self.contents.font.size = 20
for i in 0...@item_max
draw_item(i)
end
end
end
def draw_item(index)
item = @data[index]
case item
when RPG::Item
number = $game_party.item_number(item.id)
end
self.contents.font.color = normal_color
x = 4 + index % 1 * (240 + 32)
y = index / 1 * 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(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.draw_text(x + 204, y, 16, 32, ":", 1)
self.contents.draw_text(x + 220, y, 24, 32, number.to_s, 2)
end
def update_help
@help_window.set_text(self.item == nil ? "" : self.item.description)
end
end

class Window_AeonAttribute < Window_Selectable
def initialize
super(0, 0, 640, 288)
@column_max = 1
refresh
self.index = 0
end
def item
return @data[self.index]
end
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
@data = []
for i in 1...$data_items.size
if $game_party.item_number(i) > 0
if Aeon_Development::Hp_Item.include?(i) or Aeon_Development::Sp_Item.include?(i) or
Aeon_Development::Atk_Item.include?(i) or Aeon_Development::Str_Item.include?(i) or
Aeon_Development::PDef_Item.include?(i) or Aeon_Development::MDef_Item.include?(i) or
Aeon_Development::Agi_Item.include?(i) or Aeon_Development::Int_Item.include?(i) or
Aeon_Development::Dex_Item.include?(i) or Aeon_Development::Eva_Item.include?(i)
@data.push($data_items[i])
end
end
end
@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
def item_max
return @item_max
end
def draw_item(index)
item = @data[index]
number = $game_party.item_number(item.id)
self.contents.font.color = normal_color
x = 4
y = index * 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(item.icon_name)
opacity = self.contents.font.color == normal_color ? 255 : 128
n = 0
lose = 0
text = " ["
if Aeon_Development::Hp_Item.include?(item.id)
text.concat(" #{$data_system.words.hp} + #{Aeon_Development::Hp_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Hp_Item[item.id][1]
end
if Aeon_Development::Sp_Item.include?(item.id)
text.concat(" #{$data_system.words.sp} + #{Aeon_Development::Sp_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Sp_Item[item.id][1]
end
if Aeon_Development::Atk_Item.include?(item.id)
text.concat(" #{$data_system.words.atk} + #{Aeon_Development::Atk_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Atk_Item[item.id][1]
end
if Aeon_Development::Str_Item.include?(item.id)
text.concat(" #{$data_system.words.str} + #{Aeon_Development::Str_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Str_Item[item.id][1]
end
if Aeon_Development::PDef_Item.include?(item.id)
text.concat(" #{$data_system.words.pdef}. + #{Aeon_Development::PDef_Item[item.id][0]}")
n += 1
lose += Aeon_Development::PDef_Item[item.id][1]
end
if Aeon_Development::MDef_Item.include?(item.id)
text.concat(" #{$data_system.words.mdef} + #{Aeon_Development::MDef_Item[item.id][0]}")
n += 1
lose += Aeon_Development::MDef_Item[item.id][1]
end
if Aeon_Development::Agi_Item.include?(item.id)
text.concat(" #{$data_system.words.agi} + #{Aeon_Development::Agi_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Agi_Item[item.id][1]
end
if Aeon_Development::Int_Item.include?(item.id)
text.concat(" #{$data_system.words.int} + #{Aeon_Development::Int_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Int_Item[item.id][1]
end
if Aeon_Development::Dex_Item.include?(item.id)
text.concat(" #{$data_system.words.dex} + #{Aeon_Development::Dex_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Dex_Item[item.id][1]
end
if Aeon_Development::Eva_Item.include?(item.id)
text.concat(" Evasione + #{Aeon_Development::Eva_Item[item.id][0]}")
n += 1
lose += Aeon_Development::Eva_Item[item.id][1]
end
lost = lose / n
lost = lost.to_i
text.concat("]")
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
self.contents.draw_text(x + 28, y, 256, 32, item.name)
self.contents.font.color = system_color
self.contents.draw_text(x + 28 + self.contents.text_size(item.name).width, y, 256-32,32 , text)
self.contents.draw_text(x + 28 + self.contents.text_size(item.name).width + self.contents.text_size(text).width, y, 480-32,32 ," x " + lost.to_s)
self.contents.font.color = normal_color
self.contents.draw_text(x + 512, y, 128,32 ," : " + number.to_s)
end
def update_help
@help_window.set_text(self.item == nil ? "" : self.item.description)
end
end

class Window_AeonAttributeStatus < Window_Base
def initialize(actor)
super(0, 288, 640, 192)
self.contents = Bitmap.new(width - 32, height - 32)
@actor = $game_actors[actor]
refresh
end
def refresh
self.contents.clear
draw_actor_hp(@actor, 0, 0, 172)
draw_actor_sp(@actor, 256, 0, 172)
draw_actor_parameter(@actor, 0, 32, 0)
draw_actor_parameter(@actor, 0, 64, 1)
draw_actor_parameter(@actor, 0, 96, 2)
draw_actor_parameter(@actor, 0, 128, 3)
draw_actor_parameter(@actor, 256, 32, 4)
draw_actor_parameter(@actor, 256, 64, 5)
draw_actor_parameter(@actor, 256, 96, 6)
self.contents.font.color = system_color
self.contents.draw_text(256, 128, 120, 32, "Evasione")
self.contents.font.color = normal_color
self.contents.draw_text(256 + 120, 128, 36, 32, @actor.eva.to_s, 2)
end
end

class Window_AeonAbilities < Window_Selectable
def initialize
super(0, 64, 640, 480-64)
@column_max = 1
refresh
self.index = 0
end
def item
return @data[self.index]
end
def item_max
return @item_max
end
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
@data = []
for i in 1...$data_items.size
if $game_party.item_number(i) > 0
if Aeon_Development::Skill_Item.include?(i)
@data.push($data_items[i])
end
end
end
@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
def draw_item(index)
item = @data[index]
number = $game_party.item_number(item.id)
self.contents.font.color = normal_color
x = 4
y = index * 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(item.icon_name)
opacity = self.contents.font.color == normal_color ? 255 : 128
text = " [insegna #{$data_skills[Aeon_Development::Skill_Item[item.id][0]].name}]"
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
self.contents.draw_text(x + 28, y, 480-32, 32, item.name)
self.contents.font.color = system_color
self.contents.draw_text(x + 28 + self.contents.text_size(item.name).width, y, 480-32,32 , text)
self.contents.draw_text(x + 28 + self.contents.text_size(item.name).width + self.contents.text_size(text).width, y, 480-32,32 ," x " + Aeon_Development::Skill_Item[item.id][1].to_s )
self.contents.font.color = normal_color
self.contents.draw_text(x + 512, y, 128,32 ," : " + number.to_s)
end
def update_help
@help_window.set_text(self.item == nil ? "" : $data_skills[Aeon_Development::Skill_Item[self.item.id][0]].description)
end
end

class Scene_AeonStatus
def main
@command_window = Window_AeonCommand.new
@target_window = Window_AeonCommand.new
@target_window.visible = false
@target_window.active = false
@index = @command_window.actor
@info_window = Window_AeonStatus.new(@index)
@help_window = Window_Help.new
@item_window = Window_Aeon_Item.new
@choice = Window_AeonChoice.new
@choice.active = false
@item_window.active = false
@item_window.visible = false
@item_window.help_window = @help_window
@help_window.visible = false
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@command_window.dispose
@target_window.dispose
@info_window.dispose
@choice.dispose
@item_window.dispose
@help_window.dispose
end
def update
@command_window.update
@target_window.update
@info_window.update
@choice.update
@item_window.update
@help_window.update
if @command_window.active
update_command
return
end
if @choice.active
update_choice
return
end
if @item_window.active
update_item
return
end
if @target_window.active
update_target
return
end
end
def update_command
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)

$scene = Scene_Menu.new(4)
return
end
if Input.trigger?(Input::DOWN)
@info_window.dispose
@index = @command_window.actor
@info_window = Window_AeonStatus.new(@index)
end
if Input.trigger?(Input::UP)
@info_window.dispose
@index = @command_window.actor
@info_window = Window_AeonStatus.new(@index)
end
if Input.trigger?(Input::C)

$game_system.se_play($data_system.decision_se)
@choice.active = true
@command_window.active = false
return
end
end
def update_choice
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@choice.active = false
@command_window.active = true
return
end
if Input.trigger?(Input::C)
case @choice.index
when 0
$game_system.se_play($data_system.decision_se)
@item_window.active = true
@item_window.visible = true
@help_window.visible = true
@choice.active = false
@choice.visible = false
@info_window.visible = false
when 1
$game_system.se_play($data_system.decision_se)
$scene = Scene_AeonAbilities.new(@command_window.actor)
when 2
$game_system.se_play($data_system.decision_se)
$scene = Scene_AeonAttribute.new(@command_window.actor)
return
end
end
end
def update_item
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@choice.active = true
@item_window.active = false
@item_window.visible = false
@help_window.visible = false
@choice.visible = true
@info_window.visible = true
return
end
if Input.trigger?(Input::C)
@item = @item_window.item
unless @item.is_a?(RPG::Item)
$game_system.se_play($data_system.buzzer_se)
return
end
unless $game_party.item_can_use?(@item.id)
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
if @item.scope >= 3
@item_window.active = false
@item_window.visible = false
@target_window.active = true
@target_window.visible = true
@command_window.visible = false
@info_window.dispose
@index = @command_window.actor
@info_window = Window_AeonStatus.new(@index)
@info_window.visible = true
if @item.scope == 4 || @item.scope == 6
@target_window.index = -1
else
@target_window.index = 0
end
else
if @item.common_event_id > 0
$game_temp.common_event_id = @item.common_event_id
$game_system.se_play(@item.menu_se)
if @item.consumable
$game_party.lose_item(@item.id, 1)
@item_window.draw_item(@item_window.index)
end
$scene = Scene_Map.new
return
end
end
return
end
end
def update_target
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
unless $game_party.item_can_use?(@item.id)
@item_window.refresh
end
@item_window.active = true
@item_window.visible = true
@command_window.visible = true
@target_window.active = false
@target_window.visible = false
@info_window.visible = false
return
end
unless @target_window.index == -1
if Input.trigger?(Input::DOWN)
@info_window.dispose
@index = @target_window.actor
@info_window = Window_AeonStatus.new(@index)
end
if Input.trigger?(Input::UP)
@info_window.dispose
@index = @target_window.actor
@info_window = Window_AeonStatus.new(@index)
end
end
if Input.trigger?(Input::C)
if $game_party.item_number(@item.id) == 0
$game_system.se_play($data_system.buzzer_se)
return
end
if @target_window.index == -1
used = false
for i in $aeons_party
used |= $game_actors[i].item_effect(@item)
end
end
if @target_window.index >= 0
target = $game_actors[@target_window.actor]
used = target.item_effect(@item)
end
@info_window.refresh
if used
$game_system.se_play(@item.menu_se)
if @item.consumable
$game_party.lose_item(@item.id, 1)
@item_window.draw_item(@item_window.index)
end
if $game_party.all_dead?
$scene = Scene_Gameover.new
return
end
if @item.common_event_id > 0
$game_temp.common_event_id = @item.common_event_id
$scene = Scene_Map.new
return
end
end
unless used
$game_system.se_play($data_system.buzzer_se)
end
return
end
end
end

class Scene_AeonAttribute
def initialize(actor_index)
@actor_index = actor_index
end
def main
@actor = $game_actors[@actor_index]
@item_window = Window_AeonAttribute.new
@info_window = Window_AeonAttributeStatus.new(@actor_index)
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@item_window.dispose
@info_window.dispose
end
def update
@item_window.update
@info_window.update
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_AeonStatus.new
return
end
if Input.trigger?(Input::C)
@item = @item_window.item
@lose = 0
@n = 0
@number = $game_party.item_number(@item.id)
if Aeon_Development::Hp_Item.include?(@item.id) && @number >= Aeon_Development::Hp_Item[@item.id][1]
@actor.maxhp += Aeon_Development::Hp_Item[@item.id][0]
@lose += Aeon_Development::Hp_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Sp_Item.include?(@item.id) && @number >= Aeon_Development::Sp_Item[@item.id][1]
@actor.maxsp += Aeon_Development::Sp_Item[@item.id][0]
@lose += Aeon_Development::Sp_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Atk_Item.include?(@item.id) && @number >= Aeon_Development::Atk_Item[@item.id][1]
@actor.atks += Aeon_Development::Atk_Item[@item.id][0]
@lose += Aeon_Development::Atk_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Str_Item.include?(@item.id) && @number >= Aeon_Development::Str_Item[@item.id][1]
@actor.str +=Aeon_Development::Str_Item[@item.id][0]
@lose += Aeon_Development::Str_Item[@item.id][1]
@n += 1
end
if Aeon_Development::PDef_Item.include?(@item.id) && @number >= Aeon_Development::PDef_Item[@item.id][1]
@actor.pdefs += Aeon_Development::PDef_Item[@item.id][0]
@lose += Aeon_Development::PDef_Item[@item.id][1]
@n += 1
end
if Aeon_Development::MDef_Item.include?(@item.id) && @number >= Aeon_Development::MDef_Item[@item.id][1]
@actor.mdefs += Aeon_Development::MDef_Item[@item.id][0]
@lose += Aeon_Development::MDef_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Agi_Item.include?(@item.id) && @number >= Aeon_Development::Agi_Item[@item.id][1]
@actor.agi += Aeon_Development::Agi_Item[@item.id][0]
@lose += Aeon_Development::Agi_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Int_Item.include?(@item.id) && @number >= Aeon_Development::Int_Item[@item.id][1]
@actor.int += Aeon_Development::Int_Item[@item.id][0]
@lose += Aeon_Development::Int_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Dex_Item.include?(@item.id) && @number >= Aeon_Development::Dex_Item[@item.id][1]
@actor.dex += Aeon_Development::Dex_Item[@item.id][0]
@lose += Aeon_Development::Dex_Item[@item.id][1]
@n += 1
end
if Aeon_Development::Eva_Item.include?(@item.id) && @number >= Aeon_Development::Eva_Item[@item.id][1]
@actor.evas += Aeon_Development::Eva_Item[@item.id][0]
@lose += Aeon_Development::Eva_Item[@item.id][1]
@n += 1

end
@index = @item_window.index
if @n !=0
$game_party.lose_item(@item.id, (@lose/@n).to_i)
$game_system.se_play($data_system.decision_se)
else
$game_system.se_play($data_system.buzzer_se)
end
@item_window.dispose
@item_window = Window_AeonAttribute.new
@info_window.refresh
unless @index >= @item_window.item_max
@item_window.index=(@index)
else
@item_window.index=(0)
end
return
end
end
end

class Scene_AeonAbilities
def initialize(actor_index)
@actor_index = actor_index
end
def main
@actor = $game_actors[@actor_index]
@help_window = Window_Help.new
@item_window = Window_AeonAbilities.new
@item_window.help_window = @help_window
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@item_window.dispose
@help_window.dispose
end
def update
@item_window.update
@help_window.update
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_AeonStatus.new
return
end
if Input.trigger?(Input::C)
@item = @item_window.item
@number = $game_party.item_number(@item.id)
@index = @item_window.index
unless @item_window.item == nil or @actor.skill_learn?(Aeon_Development::Skill_Item[@item.id][0]) || @number < Aeon_Development::Skill_Item[@item.id][1]
@actor.learn_skill(Aeon_Development::Skill_Item[@item.id][0])
$game_system.se_play($data_system.decision_se)
$game_party.lose_item(@item.id, Aeon_Development::Skill_Item[@item.id][1])
else
$game_system.se_play($data_system.buzzer_se)
end
@item_window.dispose
@item_window = Window_AeonAbilities.new
unless @index >= @item_window.item_max
@item_window.index=(@index)
else
@item_window.index=(0)
end
return
end
end
end

else
#Se lo script richiesto non è inserito lo script viene disabilitato
print("Aeon Development disabilitato\nL'Aeon Development richiede lo script Aeon System")
end 

 

Istruzioni per l'uso

Sono all'interno degli script

Aspetto segnalazioni di bug, suggerimenti, commenti etc...

Edited March 18, 2013 by Apo
applicato tag code

[Soul Eater]

Ho provato lo script, che mi sembra davvero carino e interessante, solo che quando l'evocazione batte tutti i mostri presenti in campo da l'errore alla riga 76!!!

[DarkShika]

OK, ora voglio provarlo, poi edito il messaggio e ti dico com'è

[Tio]

Molto interessante come script, bravo Leonheart!

Al momento non ho rmxp in questo pc, però appena posso lo provo subito!

[Sleeping Leonhart]

Fixato ed aggiornato.

Adesso si possono evocare più di un eroe(tipo Magus Sister per intenderci).

Domani ci lavorerò un altro pochino sopra.

[redXIII]

ancora non lo provato ma sa k è bello complimenti

[Sleeping Leonhart]

Problema:

Come acquisiscono esperienza l'evocazioni?

Faccio che ricevono la stessa esperienza del party o che hanno dei punti esperienza propri tipo AP?

Voi cosa ne pensate?

[Soul Eater]

Io direi Esp del party che è abbastanza semplice:D!!!

[Sleeping Leonhart]

Ok ora le evocazioni prendono esperienza.(la stessa del party)

Ho fixato qualche altro bug ed ho scoperto che lo script è incompatibile con L'RTAB di cogwheel.

Purtroppo sono in una fase di stallo non sapendo cosa aggiungere allo script

qualsiasi suggerimento mi farebbe comodo.

 

Atendo risposte.

Edited August 29, 2007 by Sleeping Leonhart

[redXIII]

be...su ffx c'era nel menu una specie di status dove vedere lo sviluppo del summon...poi nn so...a me era venuto questo in mente...

[Sleeping Leonhart]

Ho aggiornato lo script!

Ora quando si evoca viene mostrata una transizione invece di far apparire le summon di botto,

ogni summon può avere la sua musichetta di battagia in più le summon possono essere chiamate solo per un tot di turni.

 

Prossimamente creerò la finestra di status per le summon ed un sistema di apprendimento per esse simile a F.F. X. (Quello con l'uso delle sfere!)

 

Spero che vi piaccia.

 

Edit:

Riaggiornato!

aggiunto lo Status Menu per le summon.

I comandi Addestra e Alleva non sono ancora inplementati

Edited September 5, 2007 by Sleeping Leonhart

[Sleeping Leonhart]

Aggiunto sviluppo attributi tramite oggetti!(alleva)

Prossimamente aggiungo addestra!

Edit:

Scusate il doppio post ho sbagliato, dovevo editare il post vecchio :P

Edited September 5, 2007 by Sleeping Leonhart

[Timisci]

Bravo Sleep.

[Soul Eater]

Stai facendo davvero un ottimo lavoro:D!!!

[Zagros]

Quando lo finisci è troppo bello!

[metaldrack]

scusate...a me non funziona ovvero quando avvio l'evocazione non mi fà attaccare e sopratutto...come si cambiano i personaggi dello script??'

[Zagros]

vedi tra le prime righe dovo puoi impostare tutto

[metaldrack]

adesso mi evoca 1 personaggio....però il problema dll'evocazione che non fà niente rimane...succede solo a me o è un bug da correggere????

ho tolto lo script delle barre hp mp e atb...e adesso funziona!!!grazie mille se riuscirò a finire il gioco ti crediterò(perchè è tutto un mistero....in 1 è un pò difficile finire un gioco)

Edited September 7, 2007 by metaldrack

[Sleeping Leonhart]

Ho aggiornato tutti e 2 gli script!

 

Ora si può disabilitare l'acquisizione di esperienza per le summon.

Le summon possono apprendere skill dagli oggetti(Alleva).

 

Edit:

Riaggiornati tutti e due gli script.

Ho aggiunto un po di feature alle summon e ho fixato un bug nello script dello sviluppo.

Edited September 12, 2007 by Sleeping Leonhart

[Deyan]

figo ^^

[AngelKing]

No aspetta un attimo ma così è troppo una figata...sto sognando??? Spero di no!!!! Scusami Sleeping Leonhart siccome nn sn molto esperto nell'inserimento ddegli script, x installarli devo creare 2 nuove pag nella finestra script e incollarceli giusto?? Xò....2 quesiti:

 

1.come le devo chiamare queste nuove pag??

2.se c'è qualche altra precisazione che devo sapere x far bfungere bn lo script plz dimmela!

 

Ancor complimenti spero nn mi svegli di botto XD!

[Sleeping Leonhart]

Ma infatti questo topic nn esiste......XD scherzo

 

Allora...

Si devi creare una pegina per ciascuno script non importa come le chiami, quella è una tua scelta.

L'unica cosa che devi sapere è che forse nn funziona con altri battle system all'infuori(si scrive così?)di quello standard(adesso non mi va di fare niente ma probabilmente lo script lo renderò compatiile con altri BS) per il resto le istruzioni sono all'interno dello sctipt.

[AngelKing]

ok e queste nuove pag le metto sopra a main o sotto??

[Sleeping Leonhart]

Sopra il main (anche perchè penso che se le metti sotto non ti legge lo script, qualsiasi esso sia.)

[AngelKing]

ok grazie mille....xò x il momento nn posso usarlo m disp xk nn è cmpatibile cn il bs di ccoa (strabello ç___ç) xò, se riesci a renderlo compatibile anke x quello sarebbe un sogno x davvero *___*!