SDK 1

#==============================================================================
# ** rmxp standard development kit (sdk)

#------------------------------------------------------------------------------
# build date - 2005-11-22
# version 1.0 - near fantastica - 2005-11-22
# version 1.1 - sephirothspawn - 2005-12-18 - (near fantastica)
# version 1.2 - near fantastica - 2005-12-18
# version 1.3 - wachunga - 2005-12-19
# version 1.4 - prexus - 2006-03-02
# version 1.5 - jimme reashu - 2006-03-25 - (near fantastica)
#------------------------------------------------------------------------------
=begin
1.0 - outline
the standard development kit (sdk) aims to increase compatibility between

rgss scripts by:
a) defining a set of scripting standards (see section 3)

b) restructuring often-used default classes and methods (see section 4)
c) providing a scripting tools module (see section 5)
#------------------------------------------------------------------------------
2.0 - modifications to the rmxp standard development kit
since edits to the sdk may cause massive capability errors, any and all
modifications must first be approved by a member of the rmxp sdk team.
the author of any modifications must be sure to update all relevant

documentation. this also includes the header, where the author is to put
the next version number with his or her name and the name of the approval
member (from the sdk team) under the latest version in the following format.
version # - name - date - (approval member name)

#------------------------------------------------------------------------------
3.0 - coding standards
to be compliant with the sdk, a script must compy with the following
coding standards:
3.1 - commenting
3.2 - classes
3.3 - variables
3.4 - aliases
3.5 - strings
3.6 - line length
3.7 - white space
3.8 - constants
3.9 - parentheses
#------------------------------------------------------------------------------
3.1 - commenting
scripts must begin with the following header:
#==============================================================================
# ** script name
#------------------------------------------------------------------------------
# your name
# version
# date
#==============================================================================
all classes and methods must have a comment describing the process or what
was added. all code added to methods that can not be aliased must be
formatted as follows:
#------------------------------------------------------------------------------
# begin script name edit
#------------------------------------------------------------------------------
[code]
#------------------------------------------------------------------------------
# end script name edit
#------------------------------------------------------------------------------
single line comments should precede the described block of code and should be
indented at the same level. code that is not self-documenting should be
commented.
however, very short comments can appear on the same line as the described
code, but should be shifted far enough to separate them from the statements.
if more than one short comment appears in a chunk of code, they should all be
indented to the same tab setting. attribute declarations should always have a
trailing comment.
#------------------------------------------------------------------------------
3.2 - classes
all classes must be named consistently with the default code, namely:
data - any class that holds data

game - any class that processes data
sprite - any class that defines a sprite
spriteset - any class that defines multiple sprites
window - any class that defines a window
arrow - any class that defines an arrow
scene - any class that defines a scene
#------------------------------------------------------------------------------
3.3 - variables
all variable names must be reasonably descriptive. use of class and global
variables should be limited. any variable used by the default system can not
have its use changed.
#------------------------------------------------------------------------------
3.4 - aliases
aliasing a method is preferable to overriding it; an alias should be used

whenever possible to increase compatibility with other scripts. all alias
names must have the following format:
yourname_scriptname_classname_methodname
#------------------------------------------------------------------------------
3.5 � strings
strings should normally be defined with single quotes ('example'); this

decreases the processing time of the engine. double quotes are useful when
using the following features:
a) substitutions, i.e. sequences that start with a backslash character
(e.g. \n for the newline character)
b) expression interpolation, i.e. #{ expression } is replaced by the value
of expression
#------------------------------------------------------------------------------
3.6 - line length
lines should not cause the the viewer to have to scroll sideways to view them
in the script editor. when the line needs to be broken, it should follow the
following guidelines, in preferential order:
break after a comma.

break before an operator.
prefer higher-level breaks to lower-level breaks.
align the new line with the beginning of the expression at the same level
on the previous line.
if the above rules lead to confusing code or to code that�s squished up

against the right margin, just indent 4 spaces instead.
#------------------------------------------------------------------------------
3.7 - white space
a blank line(s) should be used in the following places:
between sections of a source file

between class and module definitions
between attributes and the class definition
between methods
between the local variables in a method and its first statement
before a block or single-line comment
between logical sections inside a method to improve readability
blank spaces should be used in the following places:
a keyword followed by a parenthesis, e.g. if (some_boolean_statements)

after commas in argument lists, e.g. def method (arg1, arg2, ...)
all binary operators except '.', e.g. a + b; c = 1
#------------------------------------------------------------------------------
3.8 - constants
new numerical values should not be "hard-coded", except for -1, 0, and 1,
which can appear in for loops as counter values. instead, these numerical
values should be made into constant variables and these used instead.
#------------------------------------------------------------------------------
3.9 - parentheses
it is generally a good idea to use parentheses liberally in expressions

involving mixed operators to avoid operator precedence problems. even if
the operator precedence seems clear to you, it might not be to others -� you
shouldn�t assume that other programmers know precedence as well as you do.
#------------------------------------------------------------------------------
4.0 - engine updates
the following is a list of classes and methods that have been updated by the
sdk to help improve compatibility:
game_map - setup
game_map - update
game_character - update
game_event - refresh
game_player - update
sprite_battler - update
spriteset_map - initialize
spriteset_map - update
scene_tile - main
scene_map - main
scene_map - update
scene_save - write_save_data
scene_load - read_save_data
scene_menu - initialize
scene_menu - main
scene_menu - update & command input
scene_battle - main
scene_battle - update
scene_battle - update_phase3_basic_command
scene_battle - make_basic_action_result
#------------------------------------------------------------------------------
5.0 - sdk tools
the following tools are included in the sdk to help improve the development
process:
5.1 - logging scripts

5.2 - enabling/disabling scripts
5.3 - script dependencies
5.4 - standard text box input
5.5 - standard event comment input
#------------------------------------------------------------------------------
5.1 � logging scripts
all sdk-compliant scripts should be logged. this is done by calling the

sdk.log(script, name, ver, date) method, where
script = script name

name = your name
ver = version
date = date last updated
#------------------------------------------------------------------------------
5.2 � enabling/disabling scripts
when a script is logged it is also enabled. a script can be enabled and

disabled using the following calls:
sdk.enable('script name')
sdk.disable('script name')
all non-default scripts (and code added to default scripts) must be enclosed
in an if statement that checks whether or not they have been enabled, as
follows:
#--------------------------------------------------------------------------
# begin sdk enabled check
#--------------------------------------------------------------------------
if sdk.state('script name') == true
[script or code]
end
#--------------------------------------------------------------------------
# end sdk enabled test
#--------------------------------------------------------------------------
keep in mind that this if statement can not continue on to other pages and
every page needs its own if statement testing the state of the script. as
well every script should have its own test.
#------------------------------------------------------------------------------
5.3 � script dependencies
any script that requires (i.e. has a dependency on) another script can check
if that dependency is met provided that the required script is set up before
the script in question. this would be done in the following way:
p 'script name not found' if sdk.state('script name') != true

#------------------------------------------------------------------------------
5.4 � standard text box input
any script that requires input from a database text field should use the
following:
sdk.text_box_input(element, index)
where:
element = an object of the text field
index = the index in which your script call falls
the text field should be formatted in the following way:
"default value | script call | script call"

#------------------------------------------------------------------------------
5.5 � standard event comment input
any script that requires input from an event comment should use the
following:
sdk.event_comment_input(event, elements, trigger)
where:
event = an object of the event
elements = the number of elements the method is to process
trigger = the text value triggering the script to start processing
or
sdk.event_comment_input(page, elements, trigger)
where:
page = an object of the event.page
elements = the number of elements the method is to process
trigger = the text value triggering the script to start processing
the method returns nil if the trigger can not be found; otherwise, it
returns a list of the parameters from the event.
#==============================================================================
=end
module sdk
@list = {}
@enabled = {}
#--------------------------------------------------------------------------
# * logs a custom script
#--------------------------------------------------------------------------
def self.log(script, name, ver, date)
@list[script] = [name,ver,date]
@enabled[script] = true
end
#--------------------------------------------------------------------------
# * returns a list of custom scripts
#--------------------------------------------------------------------------
def self.print(script = '')
if script == ''
return @list
else
return @list[script]
end
end
#--------------------------------------------------------------------------
# * writes a list of the custom scripts to a file
#--------------------------------------------------------------------------
def self.write
file = file.open('scripts list.txt', 'wb')
for key in @list.keys
file.write("#{@list[key][0]} : #{key} version #{@list[key][1]}\n")
end
file.close
end
#--------------------------------------------------------------------------
# * returns the state of the passed script
#--------------------------------------------------------------------------
def self.state(script)
return @enabled[script]
end
#--------------------------------------------------------------------------
# * enables the passed script
#--------------------------------------------------------------------------
def self.enable(script)
@enabled[script] = true
end
#--------------------------------------------------------------------------
# * disables the passed script
#--------------------------------------------------------------------------
def self.disable(script)
@enabled[script] = false
end
#--------------------------------------------------------------------------
# * evals text from an input source
#--------------------------------------------------------------------------
def self.text_box_input(element, index)
return if index == 0
commands = element.split('|')
eval(commands[index])
end
#--------------------------------------------------------------------------
# * returns a list of parameters from an event's comments
#--------------------------------------------------------------------------
def self.event_comment_input(*args)
parameters = []
list = *args[0].list
elements = *args[1]
trigger = *args[2]
return nil if list == nil
return nil unless list.is_a?(array)
for item in list
next if item.code != 108
if item.parameters[0] == trigger
start = list.index(item) + 1
finish = start + elements
for id in start...finish
next if !list[id]
parameters.push(list[id].parameters[0])
end
return parameters
end
end
return nil
end
end
#==============================================================================
# ** object
#------------------------------------------------------------------------------
# automatic_dispose looks after disposing all windows and sprites in a scene
# when called.
#==============================================================================
class object
#--------------------------------------------------------------------------
# * automatic dispose
#--------------------------------------------------------------------------
def automatic_dispose
self.instance_variables.each do |item|
eval("#{item}.dispose if (#{item}.is_a?(sprite) or
#{item}.is_a?(window_base)) and (!#{item}.disposed?)")
end
end
end
#==============================================================================
# ** game_map
#------------------------------------------------------------------------------
# this class handles the map. it includes scrolling and passable determining
# functions. refer to "$game_map" for the instance of this class.
#==============================================================================
class game_map
#--------------------------------------------------------------------------
# * setup
# map_id : map id
#--------------------------------------------------------------------------
def setup(map_id)
setup_map_id(map_id)
setup_load
setup_tileset
setup_display
setup_refresh
setup_events
setup_common_events
setup_fog
setup_scroll
end
#--------------------------------------------------------------------------
# * setup map id
#--------------------------------------------------------------------------
def setup_map_id(map_id)
# put map id in @map_id memory
@map_id = map_id
end
#--------------------------------------------------------------------------
# * load map data
#--------------------------------------------------------------------------
def setup_load
# load map from file and set @map
@map = load_data(sprintf("data/map%03d.rxdata", @map_id))
end
#--------------------------------------------------------------------------
# * setup tileset
#--------------------------------------------------------------------------
def setup_tileset
# set tile set information in opening instance variables
tileset = $data_tilesets[@map.tileset_id]
@tileset_name = tileset.tileset_name
@autotile_names = tileset.autotile_names
@panorama_name = tileset.panorama_name
@panorama_hue = tileset.panorama_hue
@fog_name = tileset.fog_name
@fog_hue = tileset.fog_hue
@fog_opacity = tileset.fog_opacity
@fog_blend_type = tileset.fog_blend_type
@fog_zoom = tileset.fog_zoom
@fog_sx = tileset.fog_sx
@fog_sy = tileset.fog_sy
@battleback_name = tileset.battleback_name
@passages = tileset.passages
@priorities = tileset.priorities
@terrain_tags = tileset.terrain_tags
end
#--------------------------------------------------------------------------
# * setup display
#--------------------------------------------------------------------------
def setup_display
# initialize displayed coordinates
@display_x = 0
@display_y = 0
end
#--------------------------------------------------------------------------
# * setup refresh
#--------------------------------------------------------------------------
def setup_refresh
# clear refresh request flag
@need_refresh = false
end
#--------------------------------------------------------------------------
# * setup events
#--------------------------------------------------------------------------
def setup_events
# set map event data
@events = {}
for i in @map.events.keys
@events[i] = game_event.new(@map_id, @map.events[i])
end
end
#--------------------------------------------------------------------------
# * setup common events
#--------------------------------------------------------------------------
def setup_common_events
# set common event data
@common_events = {}
for i in 1...$data_common_events.size
@common_events[i] = game_commonevent.new(i)
end
end
#--------------------------------------------------------------------------
# * setup fog
#--------------------------------------------------------------------------
def setup_fog
# initialize all fog information
@fog_ox = 0
@fog_oy = 0
@fog_tone = tone.new(0, 0, 0, 0)
@fog_tone_target = tone.new(0, 0, 0, 0)
@fog_tone_duration = 0
@fog_opacity_duration = 0
@fog_opacity_target = 0
end
#--------------------------------------------------------------------------
# * setup scroll
#--------------------------------------------------------------------------
def setup_scroll
# initialize scroll information
@scroll_direction = 2
@scroll_rest = 0
@scroll_speed = 4
end
#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
update_refresh
update_scrolling
update_events
update_common_events
update_fog_scroll
update_fog_colour
update_fog
end
#--------------------------------------------------------------------------
# * refresh game map
#--------------------------------------------------------------------------
def update_refresh
# refresh map if necessary
if $game_map.need_refresh
refresh
end
end
#--------------------------------------------------------------------------
# * update scrolling
#--------------------------------------------------------------------------
def update_scrolling
# if scrolling
if @scroll_rest > 0
# change from scroll speed to distance in map coordinates
distance = 2 ** @scroll_speed
# execute scrolling
case @scroll_direction
when 2 # down
scroll_down(distance)
when 4 # left
scroll_left(distance)
when 6 # right
scroll_right(distance)
when 8 # up
scroll_up(distance)
end
# subtract distance scrolled
@scroll_rest -= distance
end
end
#--------------------------------------------------------------------------
# * update events
#--------------------------------------------------------------------------
def update_events
# update map event
for event in @events.values
event.update
end
end
#--------------------------------------------------------------------------
# * update common events
#--------------------------------------------------------------------------
def update_common_events
# update common event
for common_event in @common_events.values
common_event.update
end
end
#--------------------------------------------------------------------------
# * update fog scroll
#--------------------------------------------------------------------------
def update_fog_scroll
# manage fog scrolling
@fog_ox -= @fog_sx / 8.0
@fog_oy -= @fog_sy / 8.0
end
#--------------------------------------------------------------------------
# * update fog color
#--------------------------------------------------------------------------
def update_fog_colour
# manage change in fog color tone
if @fog_tone_duration >= 1
d = @fog_tone_duration
target = @fog_tone_target
@fog_tone.red = (@fog_tone.red * (d - 1) + target.red) / d
@fog_tone.green = (@fog_tone.green * (d - 1) + target.green) / d
@fog_tone.blue = (@fog_tone.blue * (d - 1) + target.blue) / d
@fog_tone.gray = (@fog_tone.gray * (d - 1) + target.gray) / d
@fog_tone_duration -= 1
end
end
#--------------------------------------------------------------------------
# * update fog
#--------------------------------------------------------------------------
def update_fog
# manage change in fog opacity level
if @fog_opacity_duration >= 1
d = @fog_opacity_duration
@fog_opacity = (@fog_opacity * (d - 1) + @fog_opacity_target) / d
@fog_opacity_duration -= 1
end
end
end
#==============================================================================
# ** game_character
#------------------------------------------------------------------------------
# this class deals with characters. it's used as a superclass for the
# game_player and game_event classes.
#==============================================================================
class game_character
#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
unless update_wait == true
update_movement_type
update_animation
return if update_force? == true
return if update_event_execution? == true
update_movement
end
end
#--------------------------------------------------------------------------
# * update movement type
#--------------------------------------------------------------------------
def update_movement_type
# branch with jumping, moving, and stopping
if jumping?
update_jump
elsif moving?
update_move
else
update_stop
end
end
#--------------------------------------------------------------------------
# * update animation
#--------------------------------------------------------------------------
def update_animation
# if animation count exceeds maximum value
# * maximum value is move speed * 1 taken from basic value 18
if @anime_count > 18 - @move_speed * 2
# if stop animation is off when stopping
if not @step_anime and @stop_count > 0
# return to original pattern
@pattern = @original_pattern
# if stop animation is on when moving
else
# update pattern
@pattern = (@pattern + 1) % 4
end
# clear animation count
@anime_count = 0
end
end
#--------------------------------------------------------------------------
# * update wait
#--------------------------------------------------------------------------
def update_wait
# reduce wait count
@wait_count -= 1 if @wait_count > 0
return (@wait_count > 0)
end
#--------------------------------------------------------------------------
# * update force
#--------------------------------------------------------------------------
def update_force?
# if move route is forced
if @move_route_forcing
# custom move
move_type_custom
return true
end
return false
end
#--------------------------------------------------------------------------
# * update event execution
#--------------------------------------------------------------------------
def update_event_execution?
# when waiting for event execution or locked
if @starting or lock?
# not moving by self
return true
end
return false
end
#--------------------------------------------------------------------------
# * update movement
#--------------------------------------------------------------------------
def update_movement
# if stop count exceeds a certain value (computed from move frequency)
if @stop_count > (40 - @move_frequency * 2) * (6 - @move_frequency)
# branch by move type
case @move_type
when 1 # random
move_type_random
when 2 # approach
move_type_toward_player
when 3 # custom
move_type_custom
end
end
end
end
#==============================================================================
# ** game_event
#------------------------------------------------------------------------------
# this class deals with events. it handles functions including event page
# switching via condition determinants, and running parallel process events.
# it's used within the game_map class.
#==============================================================================
class game_event < game_character

#--------------------------------------------------------------------------
# * refresh
#--------------------------------------------------------------------------
def refresh
# initialize local variable: new_page
new_page = nil
# if not temporarily erased
unless @erased
new_page = refresh_trigger_conditions
end
# if event page is the same as last time
if new_page == @page
# end method
return
end
# set @page as current event page
@page = new_page
# clear starting flag
clear_starting
# if no page fulfills conditions
if @page == nil
# reset values
refresh_reset
# end method
return
end
# set page variables
refresh_set_page
# check parallel processing
refresh_check_process
# auto event start determinant
check_event_trigger_auto
end
#--------------------------------------------------------------------------
# * refresh trigger conditions
#--------------------------------------------------------------------------
def refresh_trigger_conditions
# check in order of large event pages
for page in @event.pages.reverse
# make possible referrence for event condition with c
c = page.condition
# switch 1 condition confirmation
if c.switch1_valid
if $game_switches[c.switch1_id] == false
next
end
end
# switch 2 condition confirmation
if c.switch2_valid
if $game_switches[c.switch2_id] == false
next
end
end
# variable condition confirmation
if c.variable_valid
if $game_variables[c.variable_id] < c.variable_value
next
end
end
# self switch condition confirmation
if c.self_switch_valid
key = [@map_id, @event.id, c.self_switch_ch]
if $game_self_switches[key] != true
next
end
end
# set local variable: new_page
new_page = page
# remove loop
break
end
# return new page
return new_page
end
#--------------------------------------------------------------------------
# * refresh reset
#--------------------------------------------------------------------------
def refresh_reset
# set each instance variable
@tile_id = 0
@character_name = ""
@character_hue = 0
@move_type = 0
@through = true
@trigger = nil
@list = nil
@interpreter = nil
end
#--------------------------------------------------------------------------
# * refresh set page
#--------------------------------------------------------------------------
def refresh_set_page
# set each instance variable
@tile_id = @page.graphic.tile_id
@character_name = @page.graphic.character_name
@character_hue = @page.graphic.character_hue
if @original_direction != @page.graphic.direction
@direction = @page.graphic.direction
@original_direction = @direction
@prelock_direction = 0
end
if @original_pattern != @page.graphic.pattern
@pattern = @page.graphic.pattern
@original_pattern = @pattern
end
@opacity = @page.graphic.opacity
@blend_type = @page.graphic.blend_type
@move_type = @page.move_type
@move_speed = @page.move_speed
@move_frequency = @page.move_frequency
@move_route = @page.move_route
@move_route_index = 0
@move_route_forcing = false
@walk_anime = @page.walk_anime
@step_anime = @page.step_anime
@direction_fix = @page.direction_fix
@through = @page.through
@always_on_top = @page.always_on_top
@trigger = @page.trigger
@list = @page.list
@interpreter = nil
end
#--------------------------------------------------------------------------
# * refresh check process
#--------------------------------------------------------------------------
def refresh_check_process
# if trigger is [parallel process]
if @trigger == 4
# create parallel process interpreter
@interpreter = interpreter.new
end
end
end
#==============================================================================
# ** game_player
#------------------------------------------------------------------------------
# this class handles the player. its functions include event starting
# determinants and map scrolling. refer to "$game_player" for the one
# instance of this class.
#==============================================================================
class game_player < game_character

#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
# remember whether or not moving in local variables
last_moving = moving?
# if moving, event running, move route forcing, and message window
# display are all not occurring
unless moving? or $game_system.map_interpreter.running? or
@move_route_forcing or $game_temp.message_window_showing
update_player_movement
end
# remember coordinates in local variables
last_real_x = @real_x
last_real_y = @real_y
super
# scroll map
update_scroll_down(last_real_y)
update_scroll_left(last_real_x)
update_scroll_right(last_real_x)
update_scroll_up(last_real_y)
# if not moving
unless moving?
# if player was moving last time
if last_moving
update_encounter
end
update_action_trigger
end
end
#--------------------------------------------------------------------------
# * player movement update
#--------------------------------------------------------------------------
def update_player_movement
# move player in the direction the directional button is being pressed
case input.dir4
when 2
move_down
when 4
move_left
when 6
move_right
when 8
move_up
end
end
#--------------------------------------------------------------------------
# * scroll down
#--------------------------------------------------------------------------
def update_scroll_down(last_real_y)
# if character moves down and is positioned lower than the center
# of the screen
if @real_y > last_real_y and @real_y - $game_map.display_y > center_y
# scroll map down
$game_map.scroll_down(@real_y - last_real_y)
end
end
#--------------------------------------------------------------------------
# * scroll left
#--------------------------------------------------------------------------
def update_scroll_left(last_real_x)
# if character moves left and is positioned more let on-screen than
# center
if @real_x < last_real_x and @real_x - $game_map.display_x < center_x
# scroll map left
$game_map.scroll_left(last_real_x - @real_x)
end
end
#--------------------------------------------------------------------------
# * scroll right
#--------------------------------------------------------------------------
def update_scroll_right(last_real_x)
# if character moves right and is positioned more right on-screen than
# center
if @real_x > last_real_x and @real_x - $game_map.display_x > center_x
# scroll map right
$game_map.scroll_right(@real_x - last_real_x)
end
end
#--------------------------------------------------------------------------
# * scroll up
#--------------------------------------------------------------------------
def update_scroll_up(last_real_y)
# if character moves up and is positioned higher than the center
# of the screen
if @real_y < last_real_y and @real_y - $game_map.display_y < center_y
# scroll map up
$game_map.scroll_up(last_real_y - @real_y)
end
end
#--------------------------------------------------------------------------
# * update action trigger
#--------------------------------------------------------------------------
def update_action_trigger
# if c button was pressed
if input.trigger?(input::c)
# same position and front event determinant
check_event_trigger_here([0])
check_event_trigger_there([0,1,2])
end
end
#--------------------------------------------------------------------------
# * scroll encounter
#--------------------------------------------------------------------------
def update_encounter
# event determinant is via touch of same position event
result = check_event_trigger_here([1,2])
# if event which started does not exist
if result == false
# disregard if debug mode is on and ctrl key was pressed
unless $debug and input.press?(input::ctrl)
# encounter countdown
if @encounter_count > 0
@encounter_count -= 1
end
end
end
end
end
#==============================================================================
# ** sprite_battler
#------------------------------------------------------------------------------
# this sprite is used to display the battler.it observes the game_character
# class and automatically changes sprite conditions.
#==============================================================================
class sprite_battler
#--------------------------------------------------------------------------
# * update
#--------------------------------------------------------------------------
def update
super
# if battler is nil
if @battler == nil
remove_battler
return
end
# if file name or hue are different than current ones
redraw_battler
# if animation id is different than current one
loop_anim
# if actor which should be displayed
adjust_actor_opacity
# blink
adjust_blink
# if invisible
adjust_visibility
# if visible
if @battler_visible
# escape
sprite_escape
# white flash
sprite_white_flash
# animation
sprite_animation
# damage
sprite_damage
# collapse
sprite_collapse
end
# set sprite coordinates
self.x = @battler.screen_x
self.y = @battler.screen_y
self.z = @battler.screen_z
end
#--------------------------------------------------------------------------
# * remove battler
#--------------------------------------------------------------------------
def remove_battler
self.bitmap = nil
loop_animation(nil)
end
#--------------------------------------------------------------------------
# * redraw battler
#--------------------------------------------------------------------------
def redraw_battler
if @battler.battler_name != @battler_name or
@battler.battler_hue != @battler_hue
# get and set bitmap
@battler_name = @battler.battler_name
@battler_hue = @battler.battler_hue
self.bitmap = rpg::cache.battler(@battler_name, @battler_hue)
@width = bitmap.width
@height = bitmap.height
self.ox = @width / 2
self.oy = @height
# change opacity level to 0 when dead or hidden
if @battler.dead? or @battler.hidden
self.opacity = 0
end
end
end
#--------------------------------------------------------------------------
# * loop sprite animation
#--------------------------------------------------------------------------
def loop_anim
if @battler.damage == nil and
@battler.state_animation_id != @state_animation_id
@state_animation_id = @battler.state_animation_id
loop_animation($data_animations[@state_animation_id])
end
end
#--------------------------------------------------------------------------
# * adjust actor opacity
#--------------------------------------------------------------------------
def adjust_actor_opacity
if @battler.is_a?(game_actor) and @battler_visible
# bring opacity level down a bit when not in main phase
if $game_temp.battle_main_phase
self.opacity += 3 if self.opacity < 255
else
self.opacity -= 3 if self.opacity > 207
end
end
end
#--------------------------------------------------------------------------
# * adjust blink
#--------------------------------------------------------------------------
def adjust_blink
if @battler.blink
blink_on
else
blink_off
end
end
#--------------------------------------------------------------------------
# * adjust visibility
#--------------------------------------------------------------------------
def adjust_visibility
unless @battler_visible
# appear
if not @battler.hidden and not @battler.dead? and
(@battler.damage == nil or @battler.damage_pop)
appear
@battler_visible = true
end
end
end
#--------------------------------------------------------------------------
# * sprite: escape
#--------------------------------------------------------------------------
def sprite_escape
if @battler.hidden
$game_system.se_play($data_system.escape_se)
escape
@battler_visible = false
end
end
#--------------------------------------------------------------------------
# * sprite: white flash
#--------------------------------------------------------------------------
def sprite_white_flash
if @battler.white_flash
whiten
@battler.white_flash = false
end
end
#--------------------------------------------------------------------------
# * sprite: animation
#--------------------------------------------------------------------------
def sprite_animation
if @battler.animation_id != 0
animation = $data_animations[@battler.animation_id]
animation(animation, @battler.animation_hit)
@battler.animation_id = 0
end
end
#--------------------------------------------------------------------------
# * sprite: damage
#--------------------------------------------------------------------------
def sprite_damage
if @battler.damage_pop
damage(@battler.damage, @battler.critical)
@battler.damage = nil
@battler.critical = false
@battler.damage_pop = false
end
end
#--------------------------------------------------------------------------
# * sprite: collapse
#--------------------------------------------------------------------------
def sprite_collapse
if @battler.damage == nil and @battler.dead?
if @battler.is_a?(game_enemy)
$game_system.se_play($data_system.enemy_collapse_se)
else
$game_system.se_play($data_system.actor_collapse_se)
end
collapse
@battler_visible = false
end
end
end
#==============================================================================
# ** spriteset_map
#------------------------------------------------------------------------------
# this class brings together map screen sprites, tilemaps, etc.
# it's used within the scene_map class.
#==============================================================================
class spriteset_map
#--------------------------------------------------------------------------
# * object initialization
#--------------------------------------------------------------------------
def initialize
init_viewports
init_tilemap
init_panorama
init_fog
init_characters
init_player
init_weather
init_pictures
init_timer
# frame update
update
end
#--------------------------------------------------------------------------
# * viewport initialization
#--------------------------------------------------------------------------
def init_viewports
# make viewports
@viewport1 = viewport.new(0, 0, 640, 480)
@viewport2.z = 200
@viewport3.z = 5000
end
#--------------------------------------------------------------------------
# * tilemap initialization
#--------------------------------------------------------------------------
def init_tilemap
# make tilemap
@tilemap = tilemap.new(@viewport1)
@tilemap.tileset = rpg::cache.tileset($game_map.tileset_name)
for i in 0..6
autotile_name = $game_map.autotile_names[i]
@tilemap.autotiles[i] = rpg::cache.autotile(autotile_name)
end
@tilemap.map_data = $game_map.data
@tilemap.priorities = $game_map.priorities
end
#--------------------------------------------------------------------------
# * panorama initialization
#--------------------------------------------------------------------------
def init_panorama
# make panorama plane
@panorama = plane.new(@viewport1)
@panorama.z = -1000
end
#--------------------------------------------------------------------------
# * fog initialization
#--------------------------------------------------------------------------
def init_fog
# make fog plane
@fog = plane.new(@viewport1)
@fog.z = 3000
end
#--------------------------------------------------------------------------
# * character sprite initialization
#--------------------------------------------------------------------------
def init_characters
# make character sprites
@character_sprites = []
for i in $game_map.events.keys.sort
sprite = sprite_character.new(@viewport1, $game_map.events[i])
@character_sprites.push(sprite)
end
end
#--------------------------------------------------------------------------
# * player initialization
#--------------------------------------------------------------------------
def init_player
@character_sprites.push(sprite_character.new(@viewport1, $game_player))
end
#--------------------------------------------------------------------------
# * weather initialization
#--------------------------------------------------------------------------
def init_weather
# make weather
@weather = rpg::weather.new(@viewport1)
end
#--------------------------------------------------------------------------
# * picture initialization
#--------------------------------------------------------------------------
def init_pictures
# make picture sprites
@picture_sprites = []
for i in 1..50
@picture_sprites.push(sprite_picture.new(@viewport2,
$game_screen.pictures[i]))
end
end
#--------------------------------------------------------------------------
# * timer initialization
#--------------------------------------------------------------------------
def init_timer
# make timer sprite
@timer_sprite = sprite_timer.new
end
#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
update_panorama
update_fog
update_tilemap
update_panorama_plane
update_fog_plane
update_character_sprites
update_weather
update_picture_sprites
# update timer sprite
@timer_sprite.update
# set screen color tone and shake position
@viewport1.tone = $game_screen.tone
@viewport1.ox = $game_screen.shake
# set screen flash color
@viewport3.color = $game_screen.flash_color
# update viewports
@viewport1.update
@viewport3.update
end
#--------------------------------------------------------------------------
# * update panorama
#--------------------------------------------------------------------------
def update_panorama
# if panorama is different from current one
if @panorama_name != $game_map.panorama_name or
@panorama_hue != $game_map.panorama_hue
@panorama_name = $game_map.panorama_name
@panorama_hue = $game_map.panorama_hue
if @panorama.bitmap != nil
@panorama.bitmap.dispose
@panorama.bitmap = nil
end
if @panorama_name != ""
@panorama.bitmap = rpg::cache.panorama(@panorama_name, @panorama_hue)
end
graphics.frame_reset
end
end
#--------------------------------------------------------------------------
# * update fog
#--------------------------------------------------------------------------
def update_fog
# if fog is different than current fog
if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue
@fog_name = $game_map.fog_name
@fog_hue = $game_map.fog_hue
if @fog.bitmap != nil
@fog.bitmap.dispose
@fog.bitmap = nil
end
if @fog_name != ""
@fog.bitmap = rpg::cache.fog(@fog_name, @fog_hue)
end
graphics.frame_reset
end
end
#--------------------------------------------------------------------------
# * update tilemap
#--------------------------------------------------------------------------
def update_tilemap
# update tilemap
@tilemap.ox = $game_map.display_x / 4
@tilemap.oy = $game_map.display_y / 4
@tilemap.update
end
#--------------------------------------------------------------------------
# * update panorama plane
#--------------------------------------------------------------------------
def update_panorama_plane
# update panorama plane
@panorama.ox = $game_map.display_x / 8
@panorama.oy = $game_map.display_y / 8
end
#--------------------------------------------------------------------------
# * update fog plane
#--------------------------------------------------------------------------
def update_fog_plane
# update fog plane
@fog.zoom_x = $game_map.fog_zoom / 100.0
@fog.zoom_y = $game_map.fog_zoom / 100.0
@fog.opacity = $game_map.fog_opacity
@fog.blend_type = $game_map.fog_blend_type
@fog.ox = $game_map.display_x / 4 + $game_map.fog_ox
@fog.oy = $game_map.display_y / 4 + $game_map.fog_oy
@fog.tone = $game_map.fog_tone
end
#--------------------------------------------------------------------------
# * update character sprites
#--------------------------------------------------------------------------
def update_character_sprites
# update character sprites
for sprite in @character_sprites
sprite.update
end
end
#--------------------------------------------------------------------------
# * update weather
#--------------------------------------------------------------------------
def update_weather
# update weather graphic
@weather.type = $game_screen.weather_type
@weather.max = $game_screen.weather_max
@weather.ox = $game_map.display_x / 4
@weather.oy = $game_map.display_y / 4
@weather.update
end
#--------------------------------------------------------------------------
# * update picture sprites
#--------------------------------------------------------------------------
def update_picture_sprites
# update picture sprites
for sprite in @picture_sprites
sprite.update
end
end
end
#==============================================================================
# ** scene_title
#------------------------------------------------------------------------------
# this class performs title screen processing.
#==============================================================================
class scene_title
#--------------------------------------------------------------------------
# * main processing
#--------------------------------------------------------------------------
def main
return if main_battle_test?
main_database
main_background
main_menu
main_test_continue
main_audio
# execute transition
graphics.transition
# main loop
loop do
main_loop
break if main_scenechange?
end
# prepare for transition
graphics.freeze
main_dispose
end
#--------------------------------------------------------------------------
# * battle test check
#--------------------------------------------------------------------------
def main_battle_test?
# if battle test
if $btest
battle_test
return true
end
return false
end
#--------------------------------------------------------------------------
# * load database
#--------------------------------------------------------------------------
def main_database
# load database
$data_actors = load_data("data/actors.rxdata")
$data_classes = load_data("data/classes.rxdata")
$data_skills = load_data("data/skills.rxdata")
$data_items = load_data("data/items.rxdata")
$data_weapons = load_data("data/weapons.rxdata")
$data_armors = load_data("data/armors.rxdata")
$data_enemies = load_data("data/enemies.rxdata")
$data_troops = load_data("data/troops.rxdata")
$data_states = load_data("data/states.rxdata")
$data_animations = load_data("data/animations.rxdata")
$data_tilesets = load_data("data/tilesets.rxdata")
$data_common_events = load_data("data/commonevents.rxdata")
$data_system = load_data("data/system.rxdata")
# make system object
$game_system = game_system.new
end
#--------------------------------------------------------------------------
# * background initialization
#--------------------------------------------------------------------------
def main_background
# make title graphic
@sprite = sprite.new
@sprite.bitmap = rpg::cache.title($data_system.title_name)
end
#--------------------------------------------------------------------------
# * main menu initialization
#--------------------------------------------------------------------------
def main_menu
# make command window
s1 = "new game"
s2 = "continue"
s3 = "shutdown"
@command_window = window_command.new(192, [s1, s2, s3])
@command_window.back_opacity = 160
@command_window.x = 320 - @command_window.width / 2
@command_window.y = 288
end
#--------------------------------------------------------------------------
# * main test initialization
#--------------------------------------------------------------------------
def main_test_continue
# continue enabled determinant
# check if at least one save file exists
# if enabled, make @continue_enabled true; if disabled, make it false
@continue_enabled = false
for i in 0..3
if filetest.exist?("save#{i+1}.rxdata")
@continue_enabled = true
end
end
# if continue is enabled, move cursor to "continue"
# if disabled, display "continue" text in gray
if @continue_enabled
@command_window.index = 1
else
@command_window.disable_item(1)
end
end
#--------------------------------------------------------------------------
# * main audio initialization
#--------------------------------------------------------------------------
def main_audio
# play title bgm
$game_system.bgm_play($data_system.title_bgm)
# stop playing me and bgs
audio.me_stop
audio.bgs_stop
end
#--------------------------------------------------------------------------
# * main loop
#--------------------------------------------------------------------------
def main_loop
# update game screen
graphics.update
# update input information
input.update
# frame update
update
end
#--------------------------------------------------------------------------
# * main scene scene change
#--------------------------------------------------------------------------
def main_scenechange?
# abort loop if screen is changed
if $scene != self
return true
end
return false
end
#--------------------------------------------------------------------------
# * main dispose
#--------------------------------------------------------------------------
def main_dispose
automatic_dispose
end
end
#==============================================================================
# ** scene_map
#------------------------------------------------------------------------------
# this class performs map screen processing.
#==============================================================================
class scene_map
#--------------------------------------------------------------------------
# * main processing
#--------------------------------------------------------------------------
def main
main_draw
# main loop
loop do
main_loop
end
main_dispose
main_tiletrigger
end
#--------------------------------------------------------------------------
# * main draw
#--------------------------------------------------------------------------
def main_draw
# make sprite set
@spriteset = spriteset_map.new
# make message window
@message_window = window_message.new
# transition run
graphics.transition
end
#--------------------------------------------------------------------------
# * main loop
#--------------------------------------------------------------------------
def main_loop
graphics.update
input.update
# frame update
update
end
#--------------------------------------------------------------------------
# * main scene change
#--------------------------------------------------------------------------
if $scene != self
return true
end
return false
end
#--------------------------------------------------------------------------
# * main dispose
#--------------------------------------------------------------------------
def main_dispose
graphics.freeze
@spriteset.dispose
automatic_dispose
end
#--------------------------------------------------------------------------
# * main tiletrigger
#--------------------------------------------------------------------------
def main_tiletrigger
# if switching to title screen
if $scene.is_a?(scene_title)
# fade out screen
graphics.transition
graphics.freeze
end
end
#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
# loop
loop do
update_systems
# abort loop if player isn't place moving
unless $game_temp.player_transferring
break
end
# run place move
transfer_player
# abort loop if transition processing
if $game_temp.transition_processing
break
end
end
update_graphics
return if update_game_over? == true
return if update_to_title? == true
# if transition processing
# clear transition processing flag
$game_temp.transition_processing = false
if $game_temp.transition_name == ""
graphics.transition(20)
else
graphics.transition(40, "graphics/transitions/" +
$game_temp.transition_name)
end
end
# if showing message window
if $game_temp.message_window_showing
return
end
# if encounter list isn't empty, and encounter count is 0
if $game_player.encounter_count == 0 and $game_map.encounter_list != []
# if event is running or encounter is not forbidden
unless $game_system.map_interpreter.running? or
$game_system.encounter_disabled
# confirm troop
n = rand($game_map.encounter_list.size)
troop_id = $game_map.encounter_list[n]
# if troop is valid
if $data_troops[troop_id] != nil
# set battle calling flag
$game_temp.battle_calling = true
$game_temp.battle_troop_id = troop_id
$game_temp.battle_can_escape = true
$game_temp.battle_can_lose = false
$game_temp.battle_proc = nil
end
end
end
update_call_menu
update_call_debug
# if player is not moving
unless $game_player.moving?
update_scene
end
end
#--------------------------------------------------------------------------
# * update systems
#--------------------------------------------------------------------------
def update_systems
# update map, interpreter, and player order
# (this update order is important for when conditions are fulfilled
# to run any event, and the player isn't provided the opportunity to
# move in an instant)
$game_map.update
$game_system.map_interpreter.update
$game_player.update
# update system (timer), screen
$game_system.update
$game_screen.update
end
#--------------------------------------------------------------------------
# * update graphics
#--------------------------------------------------------------------------
def update_graphics
# update sprite set
@spriteset.update
# update message window
@message_window.update
end
#--------------------------------------------------------------------------
# * update game over
#--------------------------------------------------------------------------
def update_game_over?
# if game over
if $game_temp.gameover
# switch to game over screen
$scene = scene_gameover.new
return true
end
return false
end
#--------------------------------------------------------------------------
# * update to title
#--------------------------------------------------------------------------
def update_to_title?
# if returning to title screen
if $game_temp.to_title
# change to title screen
$scene = scene_title.new
return true
end
return false
end
#--------------------------------------------------------------------------
# * update menu call
#--------------------------------------------------------------------------
def update_call_menu
# if b button was pressed
if input.trigger?(input::b)
# if event is running, or menu is not forbidden
unless $game_system.map_interpreter.running? or
$game_system.menu_disabled
# set menu calling flag or beep flag
$game_temp.menu_calling = true
$game_temp.menu_beep = true
end
end
end
#--------------------------------------------------------------------------
# * update debug call
#--------------------------------------------------------------------------
def update_call_debug
# if debug mode is on and f9 key was pressed
if $debug and input.press?(input::f9)
# set debug calling flag
$game_temp.debug_calling = true
end
end
#--------------------------------------------------------------------------
# * update scene
#--------------------------------------------------------------------------
def update_scene
# run calling of each screen
if $game_temp.battle_calling
call_battle
elsif $game_temp.shop_calling
call_shop
elsif $game_temp.name_calling
call_name
elsif $game_temp.menu_calling
call_menu
elsif $game_temp.save_calling
call_save
elsif $game_temp.debug_calling
call_debug
end
end
end
#==============================================================================
# ** scene_menu
#------------------------------------------------------------------------------
# this class performs menu screen processing.
#==============================================================================
class scene_menu
#--------------------------------------------------------------------------
# menu_index : command cursor's initial position
#--------------------------------------------------------------------------
def initialize(menu_index = 0)
@menu_index = menu_index
commands_init
end
#--------------------------------------------------------------------------
# * set commands
#--------------------------------------------------------------------------
def commands_init
@commands = []
s1 = $data_system.words.item
s2 = $data_system.words.skill
s3 = $data_system.words.equip
s4 = "status"
s5 = "save"
s6 = "end game"
@commands.push(s1, s2, s3, s4, s5, s6).flatten!
end
#--------------------------------------------------------------------------
# * main processing
#--------------------------------------------------------------------------
def main
main_command_window
main_windows
graphics.transition
# main loop
loop do
main_loop
end
# refresh map
$game_map.refresh
graphics.freeze
main_dispose
end
#--------------------------------------------------------------------------
# * main command window
#--------------------------------------------------------------------------
def main_command_window
@command_window = window_command.new(160, @commands)
@command_window.index = @menu_index
@command_window.height = 224
# if number of party members is 0
if $game_party.actors.size == 0
# disable items, skills, equipment, and status
end
# if save is forbidden
if $game_system.save_disabled
# disable save
end
end
#--------------------------------------------------------------------------
# * main command window
#--------------------------------------------------------------------------
def main_windows
# make play time window
@playtime_window = window_playtime.new
@playtime_window.x = 0
@playtime_window.y = 224
# make steps window
@steps_window = window_steps.new
@steps_window.x = 0
@steps_window.y = 320
# make gold window
@gold_window = window_gold.new
@gold_window.x = 0
@gold_window.y = 416
# make status window
@status_window = window_menustatus.new
@status_window.x = 160
@status_window.y = 0
end
#--------------------------------------------------------------------------
# * main loop
#--------------------------------------------------------------------------
def main_loop
graphics.update
input.update
# frame update
update
end
#--------------------------------------------------------------------------
# * scene change
#--------------------------------------------------------------------------
if $scene != self
return true
end
return false
end
#--------------------------------------------------------------------------
# * main dispose
#--------------------------------------------------------------------------
def main_dispose
# dispose of windows
@command_window.dispose
@playtime_window.dispose
@steps_window.dispose
@gold_window.dispose
@status_window.dispose
end
#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
# update windows
@command_window.update
@playtime_window.update
@steps_window.update
@gold_window.update
@status_window.update
# if command window is active: call update_command
if @command_window.active
update_command
return
end
# if status window is active: call update_status
if @status_window.active
update_status
return
end
end
#--------------------------------------------------------------------------
# * frame update (when command window is active)
#--------------------------------------------------------------------------
def update_command
# play cancel se
$game_system.se_play($data_system.cancel_se)
# switch to map screen
$scene = scene_map.new
return
end
update_command_check
return
end
end
#--------------------------------------------------------------------------
# * frame update (when status window is active)
#--------------------------------------------------------------------------
def update_status
# play cancel se
# make command window active
@command_window.active = true
@status_window.active = false
@status_window.index = -1
return
end
buzzer_check
update_status_check unless buzzer_check
return
end
end
#--------------------------------------------------------------------------
# * buzzer check
#--------------------------------------------------------------------------
def buzzer_check
# if command other than save or end game, and party members = 0
if $game_party.actors.size == 0 and @command_window.index < 4
# play buzzer se
$game_system.se_play($data_system.buzzer_se)
return true
end
end
#--------------------------------------------------------------------------
# * update command check
#--------------------------------------------------------------------------
def update_command_check
# loads current command
command = @commands[@command_window.index]
# checks commands
if command == $data_system.words.item
command_item
elsif command == $data_system.words.skill
command_start_skill
elsif command == $data_system.words.equip
command_start_equip
elsif command == 'status'
command_start_status
elsif command == 'save'
command_save
elsif command == 'end game'
command_endgame
end
end
#--------------------------------------------------------------------------
# * update status check
#--------------------------------------------------------------------------
def update_status_check
command = @commands[@command_window.index]
# checks command by name
if command == $data_system.words.skill
command_skill
elsif command == $data_system.words.equip
command_equip
elsif command == 'status'
command_status
end
end
#--------------------------------------------------------------------------
# * command item
#--------------------------------------------------------------------------
def command_item
# play decision se
$game_system.se_play($data_system.decision_se)
# switch to item screen
$scene = scene_item.new
end
#--------------------------------------------------------------------------
# * command start skill
#--------------------------------------------------------------------------
def command_start_skill
activate_status
end
#--------------------------------------------------------------------------
# * command skill
#--------------------------------------------------------------------------
def command_skill
# if this actor's action limit is 2 or more
if $game_party.actors[@status_window.index].restriction >= 2
# play buzzer se
return
end
# play decision se
# switch to skill screen
$scene = scene_skill.new(@status_window.index)
end
#--------------------------------------------------------------------------
# * command start equip
#--------------------------------------------------------------------------
def command_start_equip
activate_status
end
#--------------------------------------------------------------------------
# * command equip
#--------------------------------------------------------------------------
def command_equip
# play decision se
# switch to equipment screen
$scene = scene_equip.new(@status_window.index)
end
#--------------------------------------------------------------------------
# * command start status
#--------------------------------------------------------------------------
def command_start_status
activate_status
end
#--------------------------------------------------------------------------
# * command status
#--------------------------------------------------------------------------
def command_status
# play decision se
# switch to status screen
$scene = scene_status.new(@status_window.index)
end
#--------------------------------------------------------------------------
# * command save
#--------------------------------------------------------------------------
def command_save
# if saving is forbidden
if $game_system.save_disabled
# play buzzer se
return
end
# play decision se
# switch to save screen
$scene = scene_save.new
end
#--------------------------------------------------------------------------
# * command end game
#--------------------------------------------------------------------------
def command_endgame
# play decision se
# switch to end game screen
$scene = scene_end.new
end
#--------------------------------------------------------------------------
# * activate status window
#--------------------------------------------------------------------------
def activate_status
# play decision se
# make status window active
@command_window.active = false
@status_window.active = true
@status_window.index = 0
end
end
#==============================================================================
# ** scene_save
#------------------------------------------------------------------------------
# this class performs save screen processing.
#==============================================================================
class scene_save < scene_file

#--------------------------------------------------------------------------
# * write save data
# file : write file object (opened)
#--------------------------------------------------------------------------
def write_save_data(file)
write_characters(file)
write_frame(file)
write_setup(file)
write_data(file)
end
#--------------------------------------------------------------------------
# * make character data
#--------------------------------------------------------------------------
def write_characters(file)
# make character data for drawing save file
characters = []
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
characters.push([actor.character_name, actor.character_hue])
end
# write character data for drawing save file
marshal.dump(characters, file)
end
#--------------------------------------------------------------------------
# * write frame count
#--------------------------------------------------------------------------
def write_frame(file)
# wrire frame count for measuring play time
marshal.dump(graphics.frame_count, file)
end
#--------------------------------------------------------------------------
# * write setup
#--------------------------------------------------------------------------
def write_setup(file)
# increase save count by 1
$game_system.save_count += 1
# save magic number
# (a random value will be written each time saving with editor)
$game_system.magic_number = $data_system.magic_number
end
#--------------------------------------------------------------------------
# * write data
#--------------------------------------------------------------------------
def write_data(file)
# write each type of game object
marshal.dump($game_system, file)
marshal.dump($game_switches, file)
marshal.dump($game_variables, file)
marshal.dump($game_self_switches, file)
marshal.dump($game_screen, file)
marshal.dump($game_actors, file)
marshal.dump($game_party, file)
marshal.dump($game_troop, file)
marshal.dump($game_map, file)
marshal.dump($game_player, file)
end
end
#==============================================================================
# ** scene_load
#------------------------------------------------------------------------------
# this class performs load screen processing.
#==============================================================================
class scene_load < scene_file

#--------------------------------------------------------------------------
# * read save data
# file : file object for reading (opened)
#--------------------------------------------------------------------------
def read_save_data(file)
read_characters(file)
read_frame(file)
read_data(file)
read_edit
read_refresh
end
#--------------------------------------------------------------------------
# * read character data
#--------------------------------------------------------------------------
def read_characters(file)
# read character data for drawing save file
characters = marshal.load(file)
end
#--------------------------------------------------------------------------
# * read frame count
#--------------------------------------------------------------------------
def read_frame(file)
# read frame count for measuring play time
graphics.frame_count = marshal.load(file)
end
#--------------------------------------------------------------------------
# * read data
#--------------------------------------------------------------------------
def read_data(file)
# read each type of game object
$game_system = marshal.load(file)
$game_switches = marshal.load(file)
$game_variables = marshal.load(file)
$game_self_switches = marshal.load(file)
$game_screen = marshal.load(file)
$game_actors = marshal.load(file)
$game_party = marshal.load(file)
$game_troop = marshal.load(file)
$game_map = marshal.load(file)
$game_player = marshal.load(file)
end
#--------------------------------------------------------------------------
# * read edit
#--------------------------------------------------------------------------
def read_edit
# if magic number is different from when saving
# (if editing was added with editor)
if $game_system.magic_number != $data_system.magic_number
# load map
$game_map.setup($game_map.map_id)
$game_player.center($game_player.x, $game_player.y)
end
end
#--------------------------------------------------------------------------
# * refresh game party
#--------------------------------------------------------------------------
def read_refresh
# refresh party members
$game_party.refresh
end
end
#==============================================================================
# ** scene_battle
#------------------------------------------------------------------------------
# this class performs battle screen processing.
#==============================================================================
class scene_battle
#--------------------------------------------------------------------------
# menu_index : command cursor's initial position
#--------------------------------------------------------------------------
def initialize
commands_init
end
#--------------------------------------------------------------------------
# * set commands
#--------------------------------------------------------------------------
def commands_init
@commands = []
s1 = $data_system.words.attack
s2 = $data_system.words.skill
s3 = $data_system.words.guard
s4 = $data_system.words.item
@commands.push(s1, s2, s3, s4).flatten!
end
#--------------------------------------------------------------------------
# * main processing
#--------------------------------------------------------------------------
def main
main_temp
main_troop
main_command
main_windows
main_spriteset
main_transition
# start pre-battle phase
start_phase1
graphics.transition
# main loop
loop do
main_loop
end
# refresh map
$game_map.refresh
graphics.freeze
main_dispose
main_end
end
#--------------------------------------------------------------------------
# * game temp variable setup
#--------------------------------------------------------------------------
def main_temp
# initialize each kind of temporary battle data
$game_temp.in_battle = true
$game_temp.battle_turn = 0
$game_temp.battle_event_flags.clear
$game_temp.battle_abort = false
$game_temp.battle_main_phase = false
$game_temp.battleback_name = $game_map.battleback_name
$game_temp.forcing_battler = nil
# initialize battle event interpreter
$game_system.battle_interpreter.setup(nil, 0)
end
#--------------------------------------------------------------------------
# * troop setup
#--------------------------------------------------------------------------
def main_troop
# prepare troop
@troop_id = $game_temp.battle_troop_id
$game_troop.setup(@troop_id)
end
#--------------------------------------------------------------------------
# * main command setup
#--------------------------------------------------------------------------
def main_command
@actor_command_window = window_command.new(160, @commands)
@actor_command_window.height = 160
@actor_command_window.y = 160
@actor_command_window.back_opacity = 160
@actor_command_window.active = false
@actor_command_window.visible = false
end
#--------------------------------------------------------------------------
# * scene window setup
#--------------------------------------------------------------------------
def main_windows
# make other windows
@party_command_window = window_partycommand.new
@help_window = window_help.new
@help_window.back_opacity = 160
@help_window.visible = false
@status_window = window_battlestatus.new
@message_window = window_message.new
end
#--------------------------------------------------------------------------
# * spriteset setup
#--------------------------------------------------------------------------
def main_spriteset
# make sprite set
@spriteset = spriteset_battle.new
# initialize wait count
@wait_count = 0
end
#--------------------------------------------------------------------------
# * main transition
#--------------------------------------------------------------------------
def main_transition
if $data_system.battle_transition == ""
else
$data_system.battle_transition)
end
end
#--------------------------------------------------------------------------
# * main loop
#--------------------------------------------------------------------------
def main_loop
graphics.update
input.update
# frame update
update
end
#--------------------------------------------------------------------------
# * scene change
#--------------------------------------------------------------------------
if $scene != self
return true
end
return false
end
#--------------------------------------------------------------------------
# * main dispose
#--------------------------------------------------------------------------
def main_dispose
# dispose of windows
@actor_command_window.dispose
@party_command_window.dispose
@help_window.dispose
@status_window.dispose
@message_window.dispose
@skill_window.dispose unless @skill_window == nil
@item_window.dispose unless @item_window == nil
@result_window.dispose unless @result_window == nil
# dispose of sprite set
@spriteset.dispose
end
#--------------------------------------------------------------------------
# * main end
#--------------------------------------------------------------------------
def main_end
# if switching to title screen
if $scene.is_a?(scene_title)
# fade out screen
graphics.transition
graphics.freeze
end
# if switching from battle test to any screen other than game over screen
if $btest and not $scene.is_a?(scene_gameover)
$scene = nil
end
end
#--------------------------------------------------------------------------
# * frame update
#--------------------------------------------------------------------------
def update
update_event
update_system
update_objects
update_transition
# if message window is showing
if $game_temp.message_window_showing
return
end
# if effect is showing
if @spriteset.effect?
return
end
update_scene_exit
update_abort
update_waiting
update_phase
end
#--------------------------------------------------------------------------
# * event update
#--------------------------------------------------------------------------
def update_event
# if battle event is running
if $game_system.battle_interpreter.running?
# update interpreter
$game_system.battle_interpreter.update
# if a battler which is forcing actions doesn't exist
if $game_temp.forcing_battler == nil
# if battle event has finished running
unless $game_system.battle_interpreter.running?
# rerun battle event set up if battle continues
unless judge
setup_battle_event
end
end
# if not after battle phase
if @phase != 5
# refresh status window
@status_window.refresh
end
end
end
end
#--------------------------------------------------------------------------
# * system update
#--------------------------------------------------------------------------
def update_system
# update system (timer) and screen
$game_system.update
$game_screen.update
# if timer has reached 0
if $game_system.timer_working and $game_system.timer == 0
# abort battle
$game_temp.battle_abort = true
end
end
#--------------------------------------------------------------------------
# * windows and sprites update
#--------------------------------------------------------------------------
def update_objects
# update windows
@help_window.update
@party_command_window.update
@actor_command_window.update
@status_window.update
@message_window.update
# update sprite set
@spriteset.update
end
#--------------------------------------------------------------------------
# * transition update
#--------------------------------------------------------------------------
def update_transition
# if transition is processing
# clear transition processing flag
$game_temp.transition_processing = false
if $game_temp.transition_name == ""
else
$game_temp.transition_name)
end
end
end
#--------------------------------------------------------------------------
# * scene exit update
#--------------------------------------------------------------------------
def update_scene_exit
# if game over
if $game_temp.gameover
# switch to game over screen
$scene = scene_gameover.new
return
end
# if returning to title screen
if $game_temp.to_title
# switch to title screen
$scene = scene_title.new
return
end
end
#--------------------------------------------------------------------------
# * abort update
#--------------------------------------------------------------------------
def update_abort
# if battle is aborted
if $game_temp.battle_abort
# return to bgm used before battle started
$game_system.bgm_play($game_temp.map_bgm)
# battle ends
battle_end(1)
return
end
end
#--------------------------------------------------------------------------
# * waiting update
#--------------------------------------------------------------------------
def update_waiting
# if waiting
if @wait_count > 0
# decrease wait count
@wait_count -= 1
return
end
# if battler forcing an action doesn't exist,
# and battle event is running
if $game_temp.forcing_battler == nil and
$game_system.battle_interpreter.running?
return
end
end
#--------------------------------------------------------------------------
# * phase update
#--------------------------------------------------------------------------
def update_phase
# branch according to phase
case @phase
when 1 # pre-battle phase
update_phase1
when 2 # party command phase
update_phase2
when 3 # actor command phase
update_phase3
when 4 # main phase
update_phase4
when 5 # after battle phase
update_phase5
end
end
#--------------------------------------------------------------------------
# * frame update (actor command phase : basic command)
#--------------------------------------------------------------------------
def update_phase3_basic_command
# play cancel se
# go to command input for previous actor
phase3_prior_actor
return
end
check_commands
return
end
end
#--------------------------------------------------------------------------
# * check commands
#--------------------------------------------------------------------------
def check_commands
command = @commands[@actor_command_window.index]
# branches possible commands
if command == $data_system.words.attack
update_phase3_command_attack
elsif command == $data_system.words.skill
update_phase3_command_skill
elsif command == $data_system.words.guard
update_phase3_command_guard
elsif command == $data_system.words.item
update_phase3_command_item
end
end
#--------------------------------------------------------------------------
# * command : attack
#--------------------------------------------------------------------------
def update_phase3_command_attack
# play decision se
# set action
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 0
# start enemy selection
start_enemy_select
end
#--------------------------------------------------------------------------
# * command : skill
#--------------------------------------------------------------------------
def update_phase3_command_skill
# play decision se
# set action
# start skill selection
start_skill_select
end
#--------------------------------------------------------------------------
# * command : guard
#--------------------------------------------------------------------------
def update_phase3_command_guard
# play decision se
# set action
@active_battler.current_action.basic = 1
# go to command input for next actor
phase3_next_actor
end
#--------------------------------------------------------------------------
# * command : item
#--------------------------------------------------------------------------
def update_phase3_command_item
# play decision se
# set action
# start item selection
start_item_select
end
#--------------------------------------------------------------------------
# * make basic action results
#--------------------------------------------------------------------------
def make_basic_action_result
# if attack
if @active_battler.current_action.basic == 0
make_basic_action_result_attack
return
end
# if guard
make_basic_action_result_guard
return
end
# if escape
if @active_battler.is_a?(game_enemy) and
@active_battler.current_action.basic == 2
make_basic_action_result_escape
return
end
# if doing nothing
make_basic_action_result_nothing
return
end
end
#--------------------------------------------------------------------------
# * make basic action results - attack
#--------------------------------------------------------------------------
def make_basic_action_result_attack
# set anaimation id
@animation1_id = @active_battler.animation1_id
@animation2_id = @active_battler.animation2_id
# if action battler is enemy
if @active_battler.is_a?(game_enemy)
if @active_battler.restriction == 3
target = $game_troop.random_target_enemy
elsif @active_battler.restriction == 2
target = $game_party.random_target_actor
else
index = @active_battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
end
end
# if action battler is actor
if @active_battler.is_a?(game_actor)
if @active_battler.restriction == 3
target = $game_party.random_target_actor
elsif @active_battler.restriction == 2
target = $game_troop.random_target_enemy
else
index = @active_battler.current_action.target_index
target = $game_troop.smooth_target_enemy(index)
end
end
# set array of targeted battlers
@target_battlers = [target]
# apply normal attack results
for target in @target_battlers
target.attack_effect(@active_battler)
end
end
#--------------------------------------------------------------------------
# * make basic action results - guard
#--------------------------------------------------------------------------
def make_basic_action_result_guard
# display "guard" in help window
@help_window.set_text($data_system.words.guard, 1)
end
#--------------------------------------------------------------------------
# * make basic action results - escape
#--------------------------------------------------------------------------
def make_basic_action_result_escape
# display "escape" in help window
@help_window.set_text("escape", 1)
# escape
@active_battler.escape
end
#--------------------------------------------------------------------------
# * make basic action results - nothing
#--------------------------------------------------------------------------
def make_basic_action_result_nothing
# clear battler being forced into action
$game_temp.forcing_battler = nil
# shift to step 1
@phase4_step = 1
end
end

SDK 1

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SDK 1

Uploaded by

Copyright:

Available Formats

#==============================================================================

# ** rmxp standard development kit (sdk)

the standard development kit (sdk) aims to increase compatibility between

a) defining a set of scripting standards (see section 3)

the author of any modifications must be sure to update all relevant

version # - name - date - (approval member name)

scripts must begin with the following header:

data - any class that holds data

aliasing a method is preferable to overriding it; an alias should be used

strings should normally be defined with single quotes ('example'); this

break after a comma.

if the above rules lead to confusing code or to code that�s squished up

a blank line(s) should be used in the following places:

between sections of a source file

blank spaces should be used in the following places:

a keyword followed by a parenthesis, e.g. if (some_boolean_statements)

it is generally a good idea to use parentheses liberally in expressions

5.1 - logging scripts

all sdk-compliant scripts should be logged. this is done by calling the

script = script name

when a script is logged it is also enabled. a script can be enabled and

p 'script name not found' if sdk.state('script name') != true

the text field should be formatted in the following way:

"default value | script call | script call"

sdk.event_comment_input(event, elements, trigger)

sdk.event_comment_input(page, elements, trigger)

class game_event < game_character

class game_player < game_character

class scene_save < scene_file

class scene_load < scene_file

You might also like