mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2026-01-22 22:36:03 +00:00
Updated to mkxp-z v2.1.1, renamed and rearranged some script files
This commit is contained in:
Maruno17
120
Data/Scripts/001c_Game processing/000_StartGame.rb
Normal file
120
Data/Scripts/001c_Game processing/000_StartGame.rb
Normal file
@@ -0,0 +1,120 @@
|
||||
# The Game module contains methods for saving and loading the game.
|
||||
module Game
|
||||
# Initializes various global variables and loads the game data.
|
||||
def self.initialize
|
||||
$PokemonTemp = PokemonTemp.new
|
||||
$game_temp = Game_Temp.new
|
||||
$game_system = Game_System.new
|
||||
$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')
|
||||
pbLoadBattleAnimations
|
||||
GameData.load_all
|
||||
map_file = format('Data/Map%03d.rxdata', $data_system.start_map_id)
|
||||
if $data_system.start_map_id == 0 || !pbRgssExists?(map_file)
|
||||
raise _INTL('No starting position was set in the map editor.')
|
||||
end
|
||||
end
|
||||
|
||||
# Loads bootup data from save file (if it exists) or creates bootup data (if
|
||||
# it doesn't).
|
||||
def self.set_up_system
|
||||
SaveData.move_old_windows_save if System.platform[/Windows/]
|
||||
save_data = (SaveData.exists?) ? SaveData.read_from_file(SaveData::FILE_PATH) : {}
|
||||
if save_data.empty?
|
||||
SaveData.initialize_bootup_values
|
||||
else
|
||||
SaveData.load_bootup_values(save_data)
|
||||
end
|
||||
# Set resize factor
|
||||
pbSetResizeFactor([$PokemonSystem.screensize, 4].min)
|
||||
# Set language (and choose language if there is no save file)
|
||||
if Settings::LANGUAGES.length >= 2
|
||||
$PokemonSystem.language = pbChooseLanguage if save_data.empty?
|
||||
pbLoadMessages('Data/' + Settings::LANGUAGES[$PokemonSystem.language][1])
|
||||
end
|
||||
end
|
||||
|
||||
# Called when starting a new game. Initializes global variables
|
||||
# and transfers the player into the map scene.
|
||||
def self.start_new
|
||||
if $game_map && $game_map.events
|
||||
$game_map.events.each_value { |event| event.clear_starting }
|
||||
end
|
||||
$game_temp.common_event_id = 0 if $game_temp
|
||||
$PokemonTemp.begunNewGame = true
|
||||
$scene = Scene_Map.new
|
||||
SaveData.load_new_game_values
|
||||
$MapFactory = PokemonMapFactory.new($data_system.start_map_id)
|
||||
$game_player.moveto($data_system.start_x, $data_system.start_y)
|
||||
$game_player.refresh
|
||||
$game_map.autoplay
|
||||
$game_map.update
|
||||
end
|
||||
|
||||
# Loads the game from the given save data and starts the map scene.
|
||||
# @param save_data [Hash] hash containing the save data
|
||||
# @raise [SaveData::InvalidValueError] if an invalid value is being loaded
|
||||
def self.load(save_data)
|
||||
validate save_data => Hash
|
||||
SaveData.load_all_values(save_data)
|
||||
self.load_map
|
||||
pbAutoplayOnSave
|
||||
$game_map.update
|
||||
$PokemonMap.updateMap
|
||||
$scene = Scene_Map.new
|
||||
end
|
||||
|
||||
# Loads and validates the map. Called when loading a saved game.
|
||||
def self.load_map
|
||||
$game_map = $MapFactory.map
|
||||
magic_number_matches = ($game_system.magic_number == $data_system.magic_number)
|
||||
if !magic_number_matches || $PokemonGlobal.safesave
|
||||
if pbMapInterpreterRunning?
|
||||
pbMapInterpreter.setup(nil, 0)
|
||||
end
|
||||
begin
|
||||
$MapFactory.setup($game_map.map_id)
|
||||
rescue Errno::ENOENT
|
||||
if $DEBUG
|
||||
pbMessage(_INTL('Map {1} was not found.', $game_map.map_id))
|
||||
map = pbWarpToMap
|
||||
exit unless map
|
||||
$MapFactory.setup(map[0])
|
||||
$game_player.moveto(map[1], map[2])
|
||||
else
|
||||
raise _INTL('The map was not found. The game cannot continue.')
|
||||
end
|
||||
end
|
||||
$game_player.center($game_player.x, $game_player.y)
|
||||
else
|
||||
$MapFactory.setMapChanged($game_map.map_id)
|
||||
end
|
||||
if $game_map.events.nil?
|
||||
raise _INTL('The map is corrupt. The game cannot continue.')
|
||||
end
|
||||
$PokemonEncounters = PokemonEncounters.new
|
||||
$PokemonEncounters.setup($game_map.map_id)
|
||||
end
|
||||
|
||||
# Saves the game. Returns whether the operation was successful.
|
||||
# @param save_file [String] the save file path
|
||||
# @param safe [Boolean] whether $PokemonGlobal.safesave should be set to true
|
||||
# @return [Boolean] whether the operation was successful
|
||||
# @raise [SaveData::InvalidValueError] if an invalid value is being saved
|
||||
def self.save(save_file = SaveData::FILE_PATH, safe: false)
|
||||
validate save_file => String, safe => [TrueClass, FalseClass]
|
||||
$PokemonGlobal.safesave = safe
|
||||
$game_system.save_count += 1
|
||||
$game_system.magic_number = $data_system.magic_number
|
||||
begin
|
||||
SaveData.save_to_file(save_file)
|
||||
Graphics.frame_reset
|
||||
rescue IOError, SystemCallError
|
||||
$game_system.save_count -= 1
|
||||
return false
|
||||
end
|
||||
return true
|
||||
end
|
||||
end
|
||||
447
Data/Scripts/001c_Game processing/001_Interpreter.rb
Normal file
447
Data/Scripts/001c_Game processing/001_Interpreter.rb
Normal file
@@ -0,0 +1,447 @@
|
||||
#===============================================================================
|
||||
# ** Interpreter
|
||||
#-------------------------------------------------------------------------------
|
||||
# This interpreter runs event commands. This class is used within the
|
||||
# Game_System class and the Game_Event class.
|
||||
#===============================================================================
|
||||
class Interpreter
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# depth : nest depth
|
||||
# main : main flag
|
||||
#-----------------------------------------------------------------------------
|
||||
def initialize(depth = 0, main = false)
|
||||
@depth = depth
|
||||
@main = main
|
||||
if depth > 100
|
||||
print("Common event call has exceeded maximum limit.")
|
||||
exit
|
||||
end
|
||||
clear
|
||||
end
|
||||
|
||||
def clear
|
||||
@map_id = 0 # map ID when starting up
|
||||
@event_id = 0 # event ID
|
||||
@message_waiting = false # waiting for message to end
|
||||
@move_route_waiting = false # waiting for move completion
|
||||
@wait_count = 0 # wait count
|
||||
@child_interpreter = nil # child interpreter
|
||||
@branch = {} # branch data
|
||||
@buttonInput = false
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Event Setup
|
||||
# list : list of event commands
|
||||
# event_id : event ID
|
||||
#-----------------------------------------------------------------------------
|
||||
def setup(list, event_id, map_id = nil)
|
||||
clear
|
||||
@map_id = map_id || $game_map.map_id
|
||||
@event_id = event_id
|
||||
@list = list
|
||||
@index = 0
|
||||
@branch.clear
|
||||
end
|
||||
|
||||
def setup_starting_event
|
||||
$game_map.refresh if $game_map.need_refresh
|
||||
# Set up common event if one wants to start
|
||||
if $game_temp.common_event_id > 0
|
||||
setup($data_common_events[$game_temp.common_event_id].list, 0)
|
||||
$game_temp.common_event_id = 0
|
||||
return
|
||||
end
|
||||
# Check all map events for one that wants to start, and set it up
|
||||
for event in $game_map.events.values
|
||||
next if !event.starting
|
||||
if event.trigger < 3 # Isn't autorun or parallel processing
|
||||
event.lock
|
||||
event.clear_starting
|
||||
end
|
||||
setup(event.list, event.id, event.map.map_id)
|
||||
return
|
||||
end
|
||||
# Check all common events for one that is autorun, and set it up
|
||||
for common_event in $data_common_events.compact
|
||||
next if common_event.trigger != 1 || !$game_switches[common_event.switch_id]
|
||||
setup(common_event.list, 0)
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
def running?
|
||||
return @list != nil
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Frame Update
|
||||
#-----------------------------------------------------------------------------
|
||||
def update
|
||||
@loop_count = 0
|
||||
loop do
|
||||
@loop_count += 1
|
||||
if @loop_count > 100 # Call Graphics.update for freeze prevention
|
||||
Graphics.update
|
||||
@loop_count = 0
|
||||
end
|
||||
# If this interpreter's map isn't the current map or connected to it,
|
||||
# forget this interpreter's event ID
|
||||
if $game_map.map_id != @map_id && !$MapFactory.areConnected?($game_map.map_id, @map_id)
|
||||
@event_id = 0
|
||||
end
|
||||
# Update child interpreter if one exists
|
||||
if @child_interpreter
|
||||
@child_interpreter.update
|
||||
@child_interpreter = nil if !@child_interpreter.running?
|
||||
return if @child_interpreter
|
||||
end
|
||||
# Do nothing if a message is being shown
|
||||
return if @message_waiting
|
||||
# Do nothing if any event or the player is in the middle of a move route
|
||||
if @move_route_waiting
|
||||
return if $game_player.move_route_forcing
|
||||
for event in $game_map.events.values
|
||||
return if event.move_route_forcing
|
||||
end
|
||||
@move_route_waiting = false
|
||||
end
|
||||
# Do nothing while waiting
|
||||
if @wait_count > 0
|
||||
@wait_count -= 1
|
||||
return
|
||||
end
|
||||
# Do nothing if the pause menu is going to open
|
||||
return if $game_temp.menu_calling
|
||||
# If there are no commands in the list, try to find something that wants to run
|
||||
if @list.nil?
|
||||
setup_starting_event if @main
|
||||
return if @list.nil? # Couldn't find anything that wants to run
|
||||
end
|
||||
# Execute the next command
|
||||
return if execute_command == false
|
||||
# Move to the next @index
|
||||
@index += 1
|
||||
end
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Execute script
|
||||
#-----------------------------------------------------------------------------
|
||||
def execute_script(script)
|
||||
begin
|
||||
result = eval(script)
|
||||
return result
|
||||
rescue Exception
|
||||
e = $!
|
||||
raise if e.is_a?(SystemExit) || "#{e.class}" == "Reset"
|
||||
event = get_self
|
||||
s = "Backtrace:\r\n"
|
||||
message = pbGetExceptionMessage(e)
|
||||
if e.is_a?(SyntaxError)
|
||||
script.each_line { |line|
|
||||
line.gsub!(/\s+$/, "")
|
||||
if line[/^\s*\(/]
|
||||
message += "\r\n***Line '#{line}' shouldn't begin with '('. Try\r\n"
|
||||
message += "putting the '(' at the end of the previous line instead,\r\n"
|
||||
message += "or using 'extendtext.exe'."
|
||||
end
|
||||
if line[/\:\:\s*$/]
|
||||
message += "\r\n***Line '#{line}' can't end with '::'. Try putting\r\n"
|
||||
message += "the next word on the same line, e.g. 'PBSpecies:" + ":MEW'"
|
||||
end
|
||||
}
|
||||
else
|
||||
for bt in e.backtrace[0, 10]
|
||||
s += bt + "\r\n"
|
||||
end
|
||||
s.gsub!(/Section(\d+)/) { $RGSS_SCRIPTS[$1.to_i][1] }
|
||||
end
|
||||
message = "Exception: #{e.class}\r\nMessage: " + message + "\r\n"
|
||||
message += "\r\n***Full script:\r\n#{script}\r\n"
|
||||
if event && $game_map
|
||||
map_name = ($game_map.name rescue nil) || "???"
|
||||
err = "Script error in event #{event.id} (coords #{event.x},#{event.y}), map #{$game_map.map_id} (#{map_name}):\r\n"
|
||||
err += "#{message}\r\n#{s}"
|
||||
if e.is_a?(Hangup)
|
||||
$EVENTHANGUPMSG = err
|
||||
raise
|
||||
end
|
||||
elsif $game_map
|
||||
map_name = ($game_map.name rescue nil) || "???"
|
||||
err = "Script error in map #{$game_map.map_id} (#{map_name}):\r\n"
|
||||
err += "#{message}\r\n#{s}"
|
||||
if e.is_a?(Hangup)
|
||||
$EVENTHANGUPMSG = err
|
||||
raise
|
||||
end
|
||||
else
|
||||
err = "Script error in interpreter:\r\n#{message}\r\n#{s}"
|
||||
if e.is_a?(Hangup)
|
||||
$EVENTHANGUPMSG = err
|
||||
raise
|
||||
end
|
||||
end
|
||||
raise err
|
||||
end
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Get Character
|
||||
# parameter : parameter
|
||||
#-----------------------------------------------------------------------------
|
||||
def get_character(parameter = 0)
|
||||
case parameter
|
||||
when -1 # player
|
||||
return $game_player
|
||||
when 0 # this event
|
||||
events = $game_map.events
|
||||
return (events) ? events[@event_id] : nil
|
||||
else # specific event
|
||||
events = $game_map.events
|
||||
return (events) ? events[parameter] : nil
|
||||
end
|
||||
end
|
||||
|
||||
def get_player
|
||||
return get_character(-1)
|
||||
end
|
||||
|
||||
def get_self
|
||||
return get_character(0)
|
||||
end
|
||||
|
||||
def get_event(parameter)
|
||||
return get_character(parameter)
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Freezes all events on the map (for use at the beginning of common events)
|
||||
#-----------------------------------------------------------------------------
|
||||
def pbGlobalLock
|
||||
$game_map.events.values.each { |event| event.minilock }
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Unfreezes all events on the map (for use at the end of common events)
|
||||
#-----------------------------------------------------------------------------
|
||||
def pbGlobalUnlock
|
||||
$game_map.events.values.each { |event| event.unlock }
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Gets the next index in the interpreter, ignoring certain commands between messages
|
||||
#-----------------------------------------------------------------------------
|
||||
def pbNextIndex(index)
|
||||
return -1 if !@list || @list.length == 0
|
||||
i = index + 1
|
||||
loop do
|
||||
return i if i >= @list.length - 1
|
||||
case @list[i].code
|
||||
when 118, 108, 408 # Label, Comment
|
||||
i += 1
|
||||
when 413 # Repeat Above
|
||||
i = pbRepeatAbove(i)
|
||||
when 113 # Break Loop
|
||||
i = pbBreakLoop(i)
|
||||
when 119 # Jump to Label
|
||||
newI = pbJumpToLabel(i, @list[i].parameters[0])
|
||||
i = (newI > i) ? newI : i + 1
|
||||
else
|
||||
return i
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def pbRepeatAbove(index)
|
||||
index = @list[index].indent
|
||||
loop do
|
||||
index -= 1
|
||||
return index + 1 if @list[index].indent == indent
|
||||
end
|
||||
end
|
||||
|
||||
def pbBreakLoop(index)
|
||||
indent = @list[index].indent
|
||||
temp_index = index
|
||||
loop do
|
||||
temp_index += 1
|
||||
return index + 1 if temp_index >= @list.size - 1
|
||||
return temp_index + 1 if @list[temp_index].code == 413 &&
|
||||
@list[temp_index].indent < indent
|
||||
end
|
||||
end
|
||||
|
||||
def pbJumpToLabel(index, label_name)
|
||||
temp_index = 0
|
||||
loop do
|
||||
return index + 1 if temp_index >= @list.size - 1
|
||||
return temp_index + 1 if @list[temp_index].code == 118 &&
|
||||
@list[temp_index].parameters[0] == label_name
|
||||
temp_index += 1
|
||||
end
|
||||
end
|
||||
#-----------------------------------------------------------------------------
|
||||
# * Various methods to be used in a script event command.
|
||||
#-----------------------------------------------------------------------------
|
||||
# Helper function that shows a picture in a script.
|
||||
def pbShowPicture(number, name, origin, x, y, zoomX = 100, zoomY = 100, opacity = 255, blendType = 0)
|
||||
number = number + ($game_temp.in_battle ? 50 : 0)
|
||||
$game_screen.pictures[number].show(name, origin, x, y, zoomX, zoomY, opacity, blendType)
|
||||
end
|
||||
|
||||
# Erases an event and adds it to the list of erased events so that
|
||||
# it can stay erased when the game is saved then loaded again.
|
||||
def pbEraseThisEvent
|
||||
if $game_map.events[@event_id]
|
||||
$game_map.events[@event_id].erase
|
||||
$PokemonMap.addErasedEvent(@event_id) if $PokemonMap
|
||||
end
|
||||
@index += 1
|
||||
return true
|
||||
end
|
||||
|
||||
# Runs a common event.
|
||||
def pbCommonEvent(id)
|
||||
common_event = $data_common_events[id]
|
||||
return if !common_event
|
||||
if $game_temp.in_battle
|
||||
$game_system.battle_interpreter.setup(common_event.list, 0)
|
||||
else
|
||||
interp = Interpreter.new
|
||||
interp.setup(common_event.list, 0)
|
||||
loop do
|
||||
Graphics.update
|
||||
Input.update
|
||||
interp.update
|
||||
pbUpdateSceneMap
|
||||
break if !interp.running?
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# Sets another event's self switch (eg. pbSetSelfSwitch(20, "A", true) ).
|
||||
def pbSetSelfSwitch(eventid, switch_name, value, mapid = -1)
|
||||
mapid = @map_id if mapid < 0
|
||||
old_value = $game_self_switches[[mapid, eventid, switch_name]]
|
||||
$game_self_switches[[mapid, eventid, switch_name]] = value
|
||||
if value != old_value && $MapFactory.hasMap?(mapid)
|
||||
$MapFactory.getMap(mapid, false).need_refresh = true
|
||||
end
|
||||
end
|
||||
|
||||
def tsOff?(c)
|
||||
return get_self.tsOff?(c)
|
||||
end
|
||||
alias isTempSwitchOff? tsOff?
|
||||
|
||||
def tsOn?(c)
|
||||
return get_self.tsOn?(c)
|
||||
end
|
||||
alias isTempSwitchOn? tsOn?
|
||||
|
||||
def setTempSwitchOn(c)
|
||||
get_self.setTempSwitchOn(c)
|
||||
end
|
||||
|
||||
def setTempSwitchOff(c)
|
||||
get_self.setTempSwitchOff(c)
|
||||
end
|
||||
|
||||
def getVariable(*arg)
|
||||
if arg.length == 0
|
||||
return nil if !$PokemonGlobal.eventvars
|
||||
return $PokemonGlobal.eventvars[[@map_id, @event_id]]
|
||||
else
|
||||
return $game_variables[arg[0]]
|
||||
end
|
||||
end
|
||||
|
||||
def setVariable(*arg)
|
||||
if arg.length == 1
|
||||
$PokemonGlobal.eventvars = {} if !$PokemonGlobal.eventvars
|
||||
$PokemonGlobal.eventvars[[@map_id, @event_id]] = arg[0]
|
||||
else
|
||||
$game_variables[arg[0]] = arg[1]
|
||||
$game_map.need_refresh = true
|
||||
end
|
||||
end
|
||||
|
||||
def pbGetPokemon(id)
|
||||
return $Trainer.party[pbGet(id)]
|
||||
end
|
||||
|
||||
def pbSetEventTime(*arg)
|
||||
$PokemonGlobal.eventvars = {} if !$PokemonGlobal.eventvars
|
||||
time = pbGetTimeNow
|
||||
time = time.to_i
|
||||
pbSetSelfSwitch(@event_id, "A", true)
|
||||
$PokemonGlobal.eventvars[[@map_id, @event_id]] = time
|
||||
for otherevt in arg
|
||||
pbSetSelfSwitch(otherevt, "A", true)
|
||||
$PokemonGlobal.eventvars[[@map_id, otherevt]] = time
|
||||
end
|
||||
end
|
||||
|
||||
# Used in boulder events. Allows an event to be pushed.
|
||||
def pbPushThisEvent
|
||||
event = get_self
|
||||
old_x = event.x
|
||||
old_y = event.y
|
||||
# Apply strict version of passable, which treats tiles that are passable
|
||||
# only from certain directions as fully impassible
|
||||
return if !event.can_move_in_direction?($game_player.direction, true)
|
||||
case $game_player.direction
|
||||
when 2 then event.move_down
|
||||
when 4 then event.move_left
|
||||
when 6 then event.move_right
|
||||
when 8 then event.move_up
|
||||
end
|
||||
$PokemonMap.addMovedEvent(@event_id) if $PokemonMap
|
||||
if old_x != event.x || old_y != event.y
|
||||
$game_player.lock
|
||||
loop do
|
||||
Graphics.update
|
||||
Input.update
|
||||
pbUpdateSceneMap
|
||||
break if !event.moving?
|
||||
end
|
||||
$game_player.unlock
|
||||
end
|
||||
end
|
||||
|
||||
def pbPushThisBoulder
|
||||
pbPushThisEvent if $PokemonMap.strengthUsed
|
||||
return true
|
||||
end
|
||||
|
||||
def pbSmashThisEvent
|
||||
event = get_self
|
||||
pbSmashEvent(event) if event
|
||||
@index += 1
|
||||
return true
|
||||
end
|
||||
|
||||
def pbTrainerIntro(symbol)
|
||||
return true if $DEBUG && !GameData::TrainerType.exists?(symbol)
|
||||
tr_type = GameData::TrainerType.get(symbol).id
|
||||
pbGlobalLock
|
||||
pbPlayTrainerIntroME(tr_type)
|
||||
return true
|
||||
end
|
||||
|
||||
def pbTrainerEnd
|
||||
pbGlobalUnlock
|
||||
event = get_self
|
||||
event.erase_route if event
|
||||
end
|
||||
|
||||
def setPrice(item, buy_price = -1, sell_price = -1)
|
||||
item = GameData::Item.get(item).id
|
||||
$game_temp.mart_prices[item] = [-1, -1] if !$game_temp.mart_prices[item]
|
||||
$game_temp.mart_prices[item][0] = buy_price if buy_price > 0
|
||||
if sell_price >= 0 # 0=can't sell
|
||||
$game_temp.mart_prices[item][1] = sell_price * 2
|
||||
else
|
||||
$game_temp.mart_prices[item][1] = buy_price if buy_price > 0
|
||||
end
|
||||
end
|
||||
|
||||
def setSellPrice(item, sell_price)
|
||||
setPrice(item, -1, sell_price)
|
||||
end
|
||||
end
|
||||
1027
Data/Scripts/001c_Game processing/001b_Interpreter commands.rb
Normal file
1027
Data/Scripts/001c_Game processing/001b_Interpreter commands.rb
Normal file
File diff suppressed because it is too large
Load Diff
227
Data/Scripts/001c_Game processing/002_Scene_Map.rb
Normal file
227
Data/Scripts/001c_Game processing/002_Scene_Map.rb
Normal file
@@ -0,0 +1,227 @@
|
||||
#===============================================================================
|
||||
# ** Modified Scene_Map class for Pokémon.
|
||||
#-------------------------------------------------------------------------------
|
||||
#
|
||||
#===============================================================================
|
||||
class Scene_Map
|
||||
attr_reader :spritesetGlobal
|
||||
|
||||
def spriteset
|
||||
for i in @spritesets.values
|
||||
return i if i.map==$game_map
|
||||
end
|
||||
return @spritesets.values[0]
|
||||
end
|
||||
|
||||
def createSpritesets
|
||||
@spritesetGlobal = Spriteset_Global.new
|
||||
@spritesets = {}
|
||||
for map in $MapFactory.maps
|
||||
@spritesets[map.map_id] = Spriteset_Map.new(map)
|
||||
end
|
||||
$MapFactory.setSceneStarted(self)
|
||||
updateSpritesets
|
||||
end
|
||||
|
||||
def createSingleSpriteset(map)
|
||||
temp = $scene.spriteset.getAnimations
|
||||
@spritesets[map] = Spriteset_Map.new($MapFactory.maps[map])
|
||||
$scene.spriteset.restoreAnimations(temp)
|
||||
$MapFactory.setSceneStarted(self)
|
||||
updateSpritesets
|
||||
end
|
||||
|
||||
def disposeSpritesets
|
||||
return if !@spritesets
|
||||
for i in @spritesets.keys
|
||||
next if !@spritesets[i]
|
||||
@spritesets[i].dispose
|
||||
@spritesets[i] = nil
|
||||
end
|
||||
@spritesets.clear
|
||||
@spritesets = {}
|
||||
@spritesetGlobal.dispose
|
||||
@spritesetGlobal = nil
|
||||
end
|
||||
|
||||
def autofade(mapid)
|
||||
playingBGM = $game_system.playing_bgm
|
||||
playingBGS = $game_system.playing_bgs
|
||||
return if !playingBGM && !playingBGS
|
||||
map = load_data(sprintf("Data/Map%03d.rxdata", mapid))
|
||||
if playingBGM && map.autoplay_bgm
|
||||
if (PBDayNight.isNight? rescue false)
|
||||
pbBGMFade(0.8) if playingBGM.name!=map.bgm.name && playingBGM.name!=map.bgm.name+"_n"
|
||||
else
|
||||
pbBGMFade(0.8) if playingBGM.name!=map.bgm.name
|
||||
end
|
||||
end
|
||||
if playingBGS && map.autoplay_bgs
|
||||
pbBGMFade(0.8) if playingBGS.name!=map.bgs.name
|
||||
end
|
||||
Graphics.frame_reset
|
||||
end
|
||||
|
||||
def transfer_player(cancelVehicles=true)
|
||||
$game_temp.player_transferring = false
|
||||
pbCancelVehicles($game_temp.player_new_map_id) if cancelVehicles
|
||||
autofade($game_temp.player_new_map_id)
|
||||
pbBridgeOff
|
||||
if $game_map.map_id!=$game_temp.player_new_map_id
|
||||
$MapFactory.setup($game_temp.player_new_map_id)
|
||||
end
|
||||
$game_player.moveto($game_temp.player_new_x, $game_temp.player_new_y)
|
||||
case $game_temp.player_new_direction
|
||||
when 2 then $game_player.turn_down
|
||||
when 4 then $game_player.turn_left
|
||||
when 6 then $game_player.turn_right
|
||||
when 8 then $game_player.turn_up
|
||||
end
|
||||
$game_player.straighten
|
||||
$game_map.update
|
||||
disposeSpritesets
|
||||
RPG::Cache.clear
|
||||
createSpritesets
|
||||
if $game_temp.transition_processing
|
||||
$game_temp.transition_processing = false
|
||||
Graphics.transition(20)
|
||||
end
|
||||
$game_map.autoplay
|
||||
Graphics.frame_reset
|
||||
Input.update
|
||||
end
|
||||
|
||||
def call_menu
|
||||
$game_temp.menu_calling = false
|
||||
$game_temp.in_menu = true
|
||||
$game_player.straighten
|
||||
$game_map.update
|
||||
sscene = PokemonPauseMenu_Scene.new
|
||||
sscreen = PokemonPauseMenu.new(sscene)
|
||||
sscreen.pbStartPokemonMenu
|
||||
$game_temp.in_menu = false
|
||||
end
|
||||
|
||||
def call_debug
|
||||
$game_temp.debug_calling = false
|
||||
pbPlayDecisionSE
|
||||
$game_player.straighten
|
||||
pbFadeOutIn { pbDebugMenu }
|
||||
end
|
||||
|
||||
def miniupdate
|
||||
$PokemonTemp.miniupdate = true
|
||||
loop do
|
||||
updateMaps
|
||||
$game_player.update
|
||||
$game_system.update
|
||||
$game_screen.update
|
||||
break unless $game_temp.player_transferring
|
||||
transfer_player
|
||||
break if $game_temp.transition_processing
|
||||
end
|
||||
updateSpritesets
|
||||
$PokemonTemp.miniupdate = false
|
||||
end
|
||||
|
||||
def updateMaps
|
||||
for map in $MapFactory.maps
|
||||
map.update
|
||||
end
|
||||
$MapFactory.updateMaps(self)
|
||||
end
|
||||
|
||||
def updateSpritesets
|
||||
@spritesets = {} if !@spritesets
|
||||
keys = @spritesets.keys.clone
|
||||
for i in keys
|
||||
if !$MapFactory.hasMap?(i)
|
||||
@spritesets[i].dispose if @spritesets[i]
|
||||
@spritesets[i] = nil
|
||||
@spritesets.delete(i)
|
||||
else
|
||||
@spritesets[i].update
|
||||
end
|
||||
end
|
||||
@spritesetGlobal.update
|
||||
for map in $MapFactory.maps
|
||||
@spritesets[map.map_id] = Spriteset_Map.new(map) if !@spritesets[map.map_id]
|
||||
end
|
||||
Events.onMapUpdate.trigger(self)
|
||||
end
|
||||
|
||||
def update
|
||||
loop do
|
||||
updateMaps
|
||||
pbMapInterpreter.update
|
||||
$game_player.update
|
||||
$game_system.update
|
||||
$game_screen.update
|
||||
break unless $game_temp.player_transferring
|
||||
transfer_player
|
||||
break if $game_temp.transition_processing
|
||||
end
|
||||
updateSpritesets
|
||||
if $game_temp.to_title
|
||||
$scene = pbCallTitle
|
||||
return
|
||||
end
|
||||
if $game_temp.transition_processing
|
||||
$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
|
||||
return if $game_temp.message_window_showing
|
||||
if !pbMapInterpreterRunning?
|
||||
if Input.trigger?(Input::USE)
|
||||
$PokemonTemp.hiddenMoveEventCalling = true
|
||||
elsif Input.trigger?(Input::BACK)
|
||||
unless $game_system.menu_disabled or $game_player.moving?
|
||||
$game_temp.menu_calling = true
|
||||
$game_temp.menu_beep = true
|
||||
end
|
||||
elsif Input.trigger?(Input::Z)
|
||||
unless $game_player.moving?
|
||||
$PokemonTemp.keyItemCalling = true
|
||||
end
|
||||
elsif Input.press?(Input::F9)
|
||||
$game_temp.debug_calling = true if $DEBUG
|
||||
end
|
||||
end
|
||||
unless $game_player.moving?
|
||||
if $game_temp.menu_calling
|
||||
call_menu
|
||||
elsif $game_temp.debug_calling
|
||||
call_debug
|
||||
elsif $PokemonTemp.keyItemCalling
|
||||
$PokemonTemp.keyItemCalling = false
|
||||
$game_player.straighten
|
||||
pbUseKeyItem
|
||||
elsif $PokemonTemp.hiddenMoveEventCalling
|
||||
$PokemonTemp.hiddenMoveEventCalling = false
|
||||
$game_player.straighten
|
||||
Events.onAction.trigger(self)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def main
|
||||
createSpritesets
|
||||
Graphics.transition(20)
|
||||
loop do
|
||||
Graphics.update
|
||||
Input.update
|
||||
update
|
||||
break if $scene != self
|
||||
end
|
||||
Graphics.freeze
|
||||
disposeSpritesets
|
||||
if $game_temp.to_title
|
||||
Graphics.transition(20)
|
||||
Graphics.freeze
|
||||
end
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user