From 2b9f96d07c796cd1c8f44d15d26e5410ff5c6255 Mon Sep 17 00:00:00 2001 From: infinitefusion Date: Sun, 25 Jul 2021 13:33:41 -0400 Subject: [PATCH] town map --- Data/Scripts/001_Settings.rb | 16 +- Data/Scripts/016_UI/006_UI_Summary.rb | 2 +- .../003_Debug_MenuExtraCode.rb | 7 +- .../049_Compatibility/MarinUtilities.rb | 1291 +++++++++++++++++ Data/Scripts/050_AddOns/BattleLounge.rb | 6 +- Data/Scripts/050_AddOns/BetterRegionMap.rb | 671 ++++++--- 6 files changed, 1783 insertions(+), 210 deletions(-) create mode 100644 Data/Scripts/049_Compatibility/MarinUtilities.rb diff --git a/Data/Scripts/001_Settings.rb b/Data/Scripts/001_Settings.rb index 1f07e0ec8..b3a648341 100644 --- a/Data/Scripts/001_Settings.rb +++ b/Data/Scripts/001_Settings.rb @@ -105,7 +105,7 @@ module Settings POISON_IN_FIELD = (MECHANICS_GENERATION <= 4) # Whether poisoned Pokémon will faint while walking around in the field # (true), or survive the poisoning with 1 HP (false). - POISON_FAINT_IN_FIELD = (MECHANICS_GENERATION <= 3) + POISON_FAINT_IN_FIELD = (MECHANICS_GENERATION >= 3) # Whether planted berries grow according to Gen 4 mechanics (true) or Gen 3 # mechanics (false). NEW_BERRY_PLANTS = (MECHANICS_GENERATION >= 4) @@ -150,13 +150,15 @@ module Settings # To require at least 2 badges, put true and 2. BADGE_FOR_CUT = 1 BADGE_FOR_FLASH = 2 - BADGE_FOR_ROCKSMASH = 3 - BADGE_FOR_SURF = 4 - BADGE_FOR_FLY = 5 - BADGE_FOR_STRENGTH = 6 - BADGE_FOR_DIVE = 7 + BADGE_FOR_ROCKSMASH = 0 + BADGE_FOR_SURF = 5 + BADGE_FOR_FLY = 3 + BADGE_FOR_STRENGTH = 5 + BADGE_FOR_DIVE = 9 BADGE_FOR_WATERFALL = 8 - + BADGE_FOR_TELEPORT = 3 + BADGE_FOR_BOUNCE = 8 + BADGE_FOR_ROCKCLIMB = 16 #============================================================================= # If a move taught by a TM/HM/TR replaces another move, this setting is diff --git a/Data/Scripts/016_UI/006_UI_Summary.rb b/Data/Scripts/016_UI/006_UI_Summary.rb index 38d8f218c..3e4a220be 100644 --- a/Data/Scripts/016_UI/006_UI_Summary.rb +++ b/Data/Scripts/016_UI/006_UI_Summary.rb @@ -1180,7 +1180,7 @@ class PokemonSummary_Scene if !@pokemon.egg? commands[cmdGiveItem = commands.length] = _INTL("Give item") commands[cmdTakeItem = commands.length] = _INTL("Take item") if @pokemon.hasItem? - commands[cmdPokedex = commands.length] = _INTL("View Pokédex") if $Trainer.has_pokedex + #commands[cmdPokedex = commands.length] = _INTL("View Pokédex") if $Trainer.has_pokedex end commands[cmdMark = commands.length] = _INTL("Mark") commands[commands.length] = _INTL("Cancel") diff --git a/Data/Scripts/020_Debug/003_Debug menus/003_Debug_MenuExtraCode.rb b/Data/Scripts/020_Debug/003_Debug menus/003_Debug_MenuExtraCode.rb index e0247cb8d..d8e0d4ae6 100644 --- a/Data/Scripts/020_Debug/003_Debug menus/003_Debug_MenuExtraCode.rb +++ b/Data/Scripts/020_Debug/003_Debug menus/003_Debug_MenuExtraCode.rb @@ -14,6 +14,10 @@ def pbWarpToMapId return [map_id,0,0] end +def pbWarpToMapFly + pbBetterRegionMap(0,true,true,false,nil,true) +end + def pbWarpToMap choice = pbMessage("type", [_INTL("List"),_INTL("Map id"), _INTL("Town map")], 0) if choice == 0 @@ -21,8 +25,7 @@ def pbWarpToMap elsif choice == 1 map = pbWarpToMapId elsif choice == 2 - Kernel.pbMessage("Not currently supported") - map = pbWarpToMapList + map = pbWarpToMapFly end return map end diff --git a/Data/Scripts/049_Compatibility/MarinUtilities.rb b/Data/Scripts/049_Compatibility/MarinUtilities.rb new file mode 100644 index 000000000..61a20bee6 --- /dev/null +++ b/Data/Scripts/049_Compatibility/MarinUtilities.rb @@ -0,0 +1,1291 @@ +# # PluginManager.register({ +# # :name => "Marin's Scripting Utilities", +# # :version => "1.5", +# # :credits => "Marin", +# # :link => "https://reliccastle.com/resources/165/" +# # }) +# +# # Whether or not you want the custom/better errors message. +# SPECIAL_ERRORS = true +# +# +# +# # These two settings only apply if SPECIAL_ERRORS is TRUE +# +# DOUBLE_BACKTRACE = false # The interpreter already contains a small +# # backtrace for errors in events and such by default. +# # Settings this to false will not show the custom +# # backtrace. +# +# BACKTRACE_MAX_SIZE = 12 # The backtrace can go all the way from the very first +# # call to the very last call. This is the limit as far +# # as it can go back, because you could have a massive +# # backtrace otherwise. +# +# +# class Object +# def get_variables +# return self.instance_variables.map { |v| [v,self.method(v.to_s.gsub(/@/, "").to_sym).call] } +# end +# +# def set_variables(vars) +# vars.each do |v| +# self.method((v[0].to_s.gsub(/@/, "") + "=").to_sym).call(v[1]) +# end +# end +# end +# +# # E.g. PokeBattle_Pokemon -> to_sym -> :PokeBattle_Pokemon +# class Class +# def to_sym +# return self.to_s.to_sym +# end +# end +# +# class NilClass +# def empty? +# return true +# end +# +# def numeric? +# return false +# end +# end +# +# class Numeric +# # Formats the number nicely (e.g. 1234567890 -> format() -> 1,234,567,890) +# def format(separator = ',') +# a = self.to_s.split('').reverse.breakup(3) +# return a.map { |e| e.join('') }.join(separator).reverse +# end +# +# # Makes sure the returned string is at least n characters long +# # (e.g. 4 -> to_digits -> "004") +# # (e.g. 19 -> to_digits -> "019") +# # (e.g. 123 -> to_digits -> "123") +# def to_digits(n = 3) +# str = self.to_s +# return str if str.size >= n +# ret = "" +# (n - str.size).times { ret += "0" } +# return ret + str +# end +# +# # n root of self. Defaults to 2 => square root. +# def root(n = 2) +# return (self ** (1.0 / n)) +# end +# +# # Factorial +# # 4 -> fact -> (4 * 3 * 2 * 1) -> 24 +# def fact +# raise ArgumentError, "Cannot execute factorial on negative numerics" if self < 0 +# tot = 1 +# for i in 2..self +# tot *= i +# end +# return tot +# end +# +# # Combinations +# def ncr(k) +# return (self.fact / (k.fact * (self - k).fact)) +# end +# +# # k permutations of n (self) +# def npr(k) +# return (self.fact / (self - k).fact) +# end +# +# # Converts number to binary number (returns as string) +# def to_b +# return self.to_s(2) +# end +# +# def empty? +# return false +# end +# +# def numeric? +# return true +# end +# end +# +# class NilClass +# def numeric? +# return false +# end +# end +# +# # Calculates the total amount of elements in an Enumerable. Example: +# # ["one","two","three"].fullsize #=> 11 +# module Enumerable +# def fullsize +# n = 0 +# for e in self +# if e.is_a?(String) +# n += e.size +# elsif e.respond_to?(:fullsize) +# n += e.fullsize +# elsif e.respond_to?(:size) && !e.is_a?(Numeric) +# n += e.size +# else +# n += 1 +# end +# end +# return n +# end +# end +# +# class Array +# # Returns a random element of the array +# def random +# return self[Object.method(:rand).call(self.size)] +# end +# +# # Returns whether or not the array is empty. +# def empty? +# return self.size == 0 +# end +# +# # Shuffles the order of the array +# def shuffle +# indexes = [] +# new = [] +# while new.size != self.size +# # Weird way of calling rand for compatibility +# # with Luka's scripting utilities +# i = Object.method(:rand).call(self.size) +# if !indexes.include?(i) +# indexes << i +# new << self[i] +# end +# end +# return new +# end +# +# # Shuffles the order of the array and replaces itself +# def shuffle! +# self.replace(shuffle) +# end +# +# # Breaks the array up every n elements +# def breakup(n) +# ret = [] +# for i in 0...self.size +# ret[(i / n).floor] ||= [] +# ret[(i / n).floor] << self[i] +# end +# return ret +# end +# +# # Breaks the array up every n elements and replaces itself +# def breakup!(n) +# self.replace(breakup(n)) +# end +# +# # Swaps two elements' indexes +# def swap(index1, index2) +# new = self.clone +# tmp = new[index2].clone +# new[index2] = new[index1] +# new[index1] = tmp +# return new +# end +# +# # Swaps two elements' indexes and replaces itself +# def swap!(index1, index2) +# self.replace(swap(index1, index2)) +# end +# +# # Returns whether or not the first element is equal to the passed argument +# def starts_with?(e) +# return self.first == e +# end +# +# # Returns whether or not the last element is equal to the passed argument +# def ends_with?(e) +# return self.last == e +# end +# +# # Converts itself to a hash where possible +# def to_hash(delete_nil_entries = false) +# ret = {} +# for i in 0...self.size +# next if self[i].nil? && delete_nil_entries +# ret[i] = self[i] +# end +# return ret +# end +# +# # If you have 8 elements, if true, grabs the 5th element, the 4th if false. +# # If you have 7 elements, grabs the 4th. +# def mid(round_up = true) +# i = (self.size - 1) / 2.0 +# i = i.ceil if round_up +# return self[i].floor +# end +# +# # Returns the average of all elements in the array. Will throw errors on non-numerics. +# # Skips entries. +# def average +# total = 0 +# self.each { |n| total += n unless n.nil? } +# return total / self.compact.size.to_f +# end +# +# # Adds some aliases for : , , +# alias has? include? +# alias includes? include? +# alias contains? include? +# +# # Evaluates the block you pass it for every number between 0 and "slots". +# # Example usage: +# # Array.make_table { |i| i ** 2 } +# # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] +# # Array.make_table(10..16) { |i| i.to_s(2) } +# # => ["1010", "1011", "1100", "1101", "1110", "1111", "10000"] +# # (you can also pass it an array of values to iterate over) +# def self.make_table(range = 1..10, &proc) +# return range.map { |n| next proc.call(n) } +# end +# +# # If true: +# # [0, 1, 3, 4, 5] -- etc +# # If false: +# # [0,1,2,3,4,5] -- etc +# Json_Extra_Space_After_Entry = false +# +# # Converts _self_ to a JSON string with an indent of Json_Indent_Width per layer. +# def to_json(indent = Hash::Json_Indent_Width, inline = false) +# return "[]" unless self.size > 0 +# full = "[" +# for i in 0...self.size +# nl = false +# if self[i].is_a?(Hash) || self[i].is_a?(Array) +# val = self[i].to_json(indent + Hash::Json_Indent_Width, i == 0) +# nl = !(inline && i == 0) +# else +# val = self[i] +# val = "\"#{val}\"" if val.is_a?(String) +# nl = (self.fullsize > 24 || self.map { |e| e.class.to_sym }.include?(:Hash)) +# end +# full += "\n" + " " * indent if nl +# full += val.to_s + "," +# full += " " if Json_Extra_Space_After_Entry +# end +# i = 2 + Json_Extra_Space_After_Entry.to_i +# full = full[0..(-i)] +# full += "\n#{" " * (indent - Hash::Json_Indent_Width)}" if self.fullsize > 24 || +# self.map { |e| e.class.to_sym }.include?(:Hash) +# full += "]" +# return full +# end +# end +# +# class Hash +# # Converts itself to an array where possible +# def to_array(delete_nil_entries = false) +# ret = [] +# keys = self.keys.sort +# for key in keys +# next if self[key].nil? && delete_nil_entries +# ret[key] = self[key] +# end +# return ret +# end +# +# def compact +# new = {} +# for key in self.keys +# new[key] = self[key] unless self[key].nil? +# end +# return new +# end +# +# def compact! +# self.replace(compact) +# end +# +# # Amount of spaces per "layer" in the JSON. +# Json_Indent_Width = 4 +# +# # Converts _self_ to a JSON string with an indent of Json_Indent_Width per layer. +# def to_json(indent = Json_Indent_Width, _ = nil) +# return "{}" if self.size == 0 +# full = "{" +# keys = self.keys.sort do |a,b| +# if $JSON_Sort_Order +# if $JSON_Sort_Order.include?(a) +# if $JSON_Sort_Order.include?(b) +# next $JSON_Sort_Order.index(a) <=> $JSON_Sort_Order.index(b) +# else +# next -1 +# end +# else +# if $JSON_Sort_Order.include?(b) +# next 1 +# end +# # If neither are in the key, go alphabetical +# end +# end +# if a.numeric? +# if b.numeric? +# next a <=> b +# else +# next -1 +# end +# else +# if b.numeric? +# next 1 +# else +# next a <=> b +# end +# end +# end +# for key in keys +# if self[key].is_a?(Hash) || self[key].is_a?(Array) +# val = self[key].to_json(indent + Json_Indent_Width, key == self.keys[0]) +# else +# val = self[key] +# val = "\"#{val}\"" if val.is_a?(String) +# end +# full += "\n#{" " * indent}\"#{key}\": #{val}," +# end +# full = full[0..-2] +# full += "\n#{" " * (indent - Json_Indent_Width)}}" +# return full +# end +# end +# +# # String class extensions +# class String +# # Converts to bits +# def to_b +# return self.unpack('b*')[0] +# end +# +# # Converts to bits and replaces itself +# def to_b! +# self.replace(to_b) +# end +# +# # Converts from bits +# def from_b +# return [self].pack('b*') +# end +# +# # Convert from bits and replaces itself +# def from_b! +# self.replace(from_b) +# end +# +# # Returns a random character from the string +# def random +# return self[rand(self.size)] +# end +# +# # Shuffles the order of the characters +# def shuffle +# return self.split("").shuffle.join("") +# end +# +# # Breaks the string up every _n_ characters +# def breakup(n) +# new = [] +# for i in 0...self.size +# new[(i / n).floor] ||= "" +# new[(i / n).floor] += self[i] +# end +# return new +# end +# +# def empty? +# return (self.size == 0) +# end +# +# def numeric? +# i = 0 +# for e in self.split("") +# next if i == 0 && e == "-" +# return false unless [0,1,2,3,4,5,6,7,8,9].map { |n| n.to_s }.include?(e) +# end +# return true +# end +# +# # Deflates itself and returns the result +# def deflate +# return Zlib::Deflate.deflate(self) +# end +# +# # Deflates and replaces itself +# def deflate! +# self.replace(deflate) +# end +# +# # Inflates itself and returns the result +# def inflate +# return Zlib::Inflate.inflate(self) +# end +# +# # Inflates and replaces itself +# def inflate! +# self.replace(inflate) +# end +# +# # Adds some aliases for : , , +# alias has? include? +# alias includes? include? +# alias contains? include? +# end +# +# # File class extensions +# class File +# # Copies the source file to the destination path. +# def self.copy(source, destination) +# data = "" +# t = Time.now +# File.open(source, 'rb') do |f| +# while r = f.read(4096) +# if Time.now - t > 1 +# Graphics.update +# t = Time.now +# end +# data += r +# end +# end +# File.delete(destination) if File.file?(destination) +# f = File.new(destination, 'wb') +# f.write data +# f.close +# end +# +# # Renames the old file to be the new file. //exact same as File::move +# def self.rename(old, new) +# File.move(old, new) +# end +# +# # Copies the source to the destination and deletes the source. +# def self.move(source, destination) +# File.copy(source, destination) +# File.delete(source) +# end +# +# # Reads the file's data and inflates it with Zlib +# def self.inflate(file) +# data = "" +# t = Time.now +# File.open(file, 'rb') do |f| +# while r = f.read(4096) +# if Time.now - t > 1 +# Graphics.update +# t = Time.now +# end +# data += r +# end +# end +# data.inflate! +# File.delete(file) +# f = File.new(file, 'wb') +# f.write data +# f.close +# return data +# end +# +# # Reads the file's data and deflates it with Zlib +# def self.deflate(file) +# data = "" +# t = Time.now +# File.open(file, 'rb') do |f| +# while r = f.read(4096) +# if Time.now - t > 1 +# Graphics.update +# t = Time.now +# end +# data += r +# end +# end +# data.deflate! +# File.delete(file) +# f = File.new(file, 'wb') +# f.write data +# f.close +# return data +# end +# +# # Note: This is VERY basic compression and should NOT serve as encryption. +# # Compresses all specified files into one, big package +# def self.compress(outfile, files, delete_files = true) +# start = Time.now +# files = [files] unless files.is_a?(Array) +# for i in 0...files.size +# if !File.file?(files[i]) +# raise "Could not find part of the path `#{files[i]}`" +# end +# end +# files.breakup(500) # 500 files per compressed file +# full = "" +# t = Time.now +# for i in 0...files.size +# if Time.now - t > 1 +# Graphics.update +# t = Time.now +# end +# data = "" +# File.open(files[i], 'rb') do |f| +# while r = f.read(4096) +# if Time.now - t > 1 +# Graphics.update +# t = Time.now +# end +# data += r +# end +# end +# File.delete(files[i]) if delete_files +# full += "#{data.size}|#{files[i]}|#{data}" +# full += "|" if i != files.size - 1 +# end +# File.delete(outfile) if File.file?(outfile) +# f = File.new(outfile, 'wb') +# f.write full.deflate +# f.close +# return Time.now - start +# end +# +# # Decompresses files compressed with File.compress +# def self.decompress(filename, delete_package = true) +# start = Time.now +# data = "" +# t = Time.now +# File.open(filename, 'rb') do |f| +# while r = f.read(4096) +# if Time.now - t > 1 +# Graphics.update +# t = Time.now +# end +# data += r +# end +# end +# data.inflate! +# loop do +# size, name = data.split('|') +# data = data.split(size + "|" + name + "|")[1..-1].join(size + "|" + name + "|") +# size = size.to_i +# content = data[0...size] +# data = data[(size + 1)..-1] +# File.delete(name) if File.file?(name) +# f = File.new(name, 'wb') +# f.write content +# f.close +# break if !data || data.size == 0 || data.split('|').size <= 1 +# end +# File.delete(filename) if delete_package +# return Time.now - start +# end +# +# # Creates all directories that don't exist in the given path, as well as the +# # file. If given a second argument, it'll write that to the file. +# def self.create(path, data = nil) +# start = Time.now +# Dir.create(path.split('/')[0..-2].join('/')) +# f = File.new(path, 'wb') +# f.write data if data && data.size > 0 +# f.close +# return Time.now - start +# end +# end +# +# # Dir class extensions +# class Dir +# class << Dir +# alias marin_delete delete +# end +# +# # Returns all files in the targeted path +# def self.get_files(path, recursive = true) +# return Dir.get_all(path, recursive).select { |path| File.file?(path) } +# end +# +# # Returns all directories in the targeted path +# def self.get_dirs(path, recursive = true) +# return Dir.get_all(path, recursive).select { |path| File.directory?(path) } +# end +# +# # Returns all files and directories in the targeted path +# def self.get_all(path, recursive = true) +# files = [] +# Dir.foreach(path) do |f| +# next if f == "." || f == ".." +# if File.directory?(path + "/" + f) && recursive +# files.concat(Dir.get_files(path + "/" + f)) +# end +# files << path + "/" + f +# end +# return files +# end +# +# # Deletes a directory and all files/directories within, unless non_empty is false +# def self.delete(path, non_empty = true) +# if non_empty +# for file in Dir.get_all(path) +# if File.directory?(file) +# Dir.delete(file, non_empty) +# elsif File.file?(file) +# File.delete(file) +# end +# end +# end +# marin_delete(path) +# end +# +# # Creates all directories that don't exist in the given path. +# def self.create(path) +# split = path.split('/') +# for i in 0...split.size +# Dir.mkdir(split[0..i].join('/')) unless File.directory?(split[0..i].join('/')) +# end +# end +# end +# +# +# Sprite class extensions +class Sprite + # Shorthand for initializing a bitmap by path, bitmap, or width/height: + # -> bmp("Graphics/Pictures/bag") + # -> bmp(32, 32) + # -> bmp(some_other_bitmap) + def bmp(arg1 = nil, arg2 = nil) + if arg1 + if arg2 + arg1 = Graphics.width if arg1 == -1 + arg2 = Graphics.height if arg2 == -1 + self.bitmap = Bitmap.new(arg1, arg2) + elsif arg1.is_a?(Bitmap) + self.bitmap = arg1.clone + else + self.bitmap = Bitmap.new(arg1) + end + else + return self.bitmap + end + end + + # Alternative to bmp(path): + # -> bmp = "Graphics/Pictures/bag" + def bmp=(arg1) + bmp(arg1) + end + + # Usage: + # -> [x] # Sets sprite.x to x + # -> [x,y] # Sets sprite.x to x and sprite.y to y + # -> [x,y,z] # Sets sprite.x to x and sprite.y to y and sprite.z to z + # -> [nil,y] # Sets sprite.y to y + # -> [nil,nil,z] # Sets sprite.z to z + # -> [x,nil,z] # Sets sprite.x to x and sprite.z to z + # Etc. + def xyz=(args) + self.x = args[0] || self.x + self.y = args[1] || self.y + self.z = args[2] || self.z + end + + # Returns the x, y, and z coordinates in the xyz=(args) format, [x,y,z] + def xyz + return [self.x,self.y,self.z] + end + + # Centers the sprite by setting the origin points to half the width and height + def center_origins + return if !self.bitmap + self.ox = self.bitmap.width / 2 + self.oy = self.bitmap.height / 2 + end + + # Returns the sprite's full width, taking zoom_x into account + def fullwidth + return self.bitmap.width.to_f * self.zoom_x + end + + # Returns the sprite's full height, taking zoom_y into account + def fullheight + return self.bitmap.height.to_f * self.zoom_y + end +end +# +class TextSprite < Sprite + # Sets up the sprite and bitmap. You can also pass text to draw + # either an array of arrays, or an array containing the normal "parameters" + # for drawing text: + # [text,x,y,align,basecolor,shadowcolor] + def initialize(viewport = nil, text = nil, width = -1, height = -1) + super(viewport) + @width = width + @height = height + self.bmp(@width, @height) + pbSetSystemFont(self.bmp) + if text.is_a?(Array) + if text[0].is_a?(Array) + pbDrawTextPositions(self.bmp,text) + else + pbDrawTextPositions(self.bmp,[text]) + end + end + end + + # Clears the bitmap (and thus all drawn text) + def clear + self.bmp.clear + pbSetSystemFont(self.bmp) + end + + # You can also pass text to draw either an array of arrays, or an array + # containing the normal "parameters" for drawing text: + # [text,x,y,align,basecolor,shadowcolor] + def draw(text, clear = false) + self.clear if clear + if text[0].is_a?(Array) + pbDrawTextPositions(self.bmp,text) + else + pbDrawTextPositions(self.bmp,[text]) + end + end + + # Draws text with outline + # [text,x,y,align,basecolor,shadowcolor] + def draw_outline(text, clear = false) + self.clear if clear + if text[0].is_a?(Array) + for e in text + e[2] -= 224 + pbDrawOutlineText(self.bmp,e[1],e[2],640,480,e[0],e[4],e[5],e[3]) + end + else + e = text + e[2] -= 224 + pbDrawOutlineText(self.bmp,e[1],e[2],640,480,e[0],e[4],e[5],e[3]) + end + end + + # Draws and breaks a line if the width is exceeded + # [text,x,y,width,numlines,basecolor,shadowcolor] + def draw_ex(text, clear = false) + self.clear if clear + if text[0].is_a?(Array) + for e in text + drawTextEx(self.bmp,e[1],e[2],e[3],e[4],e[0],e[5],e[6]) + end + else + e = text + drawTextEx(self.bmp,e[1],e[2],e[3],e[4],e[0],e[5],e[6]) + end + end + + # Clears and disposes the sprite + def dispose + clear + super + end +end + +# A better alternative to the typical @sprites = {} +class SpriteHash + attr_reader :x + attr_reader :y + attr_reader :z + attr_reader :visible + attr_reader :opacity + + def initialize + @hash = {} + @x = 0 + @y = 0 + @z = 0 + @visible = true + @opacity = 255 + end + + # Returns the object in the specified key + def [](key) + key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric) + return @hash[key] + end + + # Sets an object in specified key to the specified value + def []=(key, value) + key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric) + add(key, value) + end + + # Returns the raw hash + def raw + return @hash + end + + # Returns the keys in the hash + def keys + return @hash.keys + end + + def length; return self.size; end + def count; return self.size; end + + # Returns the amount of keys in the hash + def size + return @hash.keys.size + end + + # Clones the hash + def clone + return @hash.clone + end + + # Adds an object to the specified key + def add(key, value) + clear_disposed + key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric) + @hash[key] if @hash[key] && @hash[key].respond_to?(:dispose) + @hash[key] = value + clear_disposed + end + + # Deletes an object in the specified key + def delete(key) + key = key.to_sym if key.respond_to?(:to_sym) && !key.is_a?(Numeric) + @hash[key] = nil + clear_disposed + end + + # Iterates over all sprites + def each + clear_disposed + @hash.each { |s| yield s[1] if block_given? } + end + + # Updates all sprites + def update + clear_disposed + for key in @hash.keys + @hash[key].update if @hash[key].respond_to?(:update) + end + end + + # Disposes all sprites + def dispose + clear_disposed + for key in @hash.keys + @hash[key].dispose if @hash[key].respond_to?(:dispose) + end + clear_disposed + end + + # Compatibility + def disposed? + return false + end + + # Changes x on all sprites + def x=(value) + clear_disposed + for key in @hash.keys + @hash[key].x += value - @x + end + @x = value + end + + # Changes y on all sprites + def y=(value) + clear_disposed + for key in @hash.keys + @hash[key].y += value - @y + end + @y = value + end + + # Changes z on all sprites + def z=(value) + clear_disposed + for key in @hash.keys + @hash[key].z += value - @z + end + @z = value + end + + # Changes visibility on all sprites + def visible=(value) + clear_disposed + for key in @hash.keys + @hash[key].visible = value + end + end + + # Changes opacity on all sprites + def opacity=(value) + clear_disposed + for key in @hash.keys + @hash[key].opacity += value - @opacity + end + @opacity = [0,value,255].sort[1] + end + + # Fades out all sprites + def hide(frames = 16) + clear_disposed + frames.times do + Graphics.update + Input.update + for key in @hash.keys + @hash[key].opacity -= 255 / frames.to_f + end + end + @opacity = 0 + end + + # Fades in all sprites + def show(frames = 16) + clear_disposed + frames.times do + Graphics.update + Input.update + for key in @hash.keys + @hash[key].opacity += 255 / frames.to_f + end + end + @opacity = 255 + end + + # Deletes all disposed sprites from the hash + def clear_disposed + for key in @hash.keys + if (@hash[key].disposed? rescue true) + @hash[key] = nil + @hash.delete(key) + end + end + end + + # Renames the old key to the new key + def rename(old, new) + self[new] = self[old] + delete(old) + end +end + +# class ByteWriter +# def initialize(filename) +# @file = File.new(filename, "wb") +# end +# +# def <<(*data) +# write(*data) +# end +# +# def write(*data) +# data.each do |e| +# if e.is_a?(Array) +# e.each { |item| write(item) } +# elsif e.is_a?(Numeric) +# @file.putc e +# else +# raise "Invalid data for writing." +# end +# end +# end +# +# def write_int(int) +# self << ByteWriter.to_bytes(int) +# end +# +# def close +# @file.close +# @file = nil +# end +# +# def self.to_bytes(int) +# return [ +# (int >> 24) & 0xFF, +# (int >> 16) & 0xFF, +# (int >> 8) & 0xFF, +# int & 0xFF +# ] +# end +# end + +# class Bitmap +# def save_to_png(filename) +# f = ByteWriter.new(filename) +# +# #============================= Writing header ===============================# +# # PNG signature +# f << [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A] +# # Header length +# f << [0x00, 0x00, 0x00, 0x0D] +# # IHDR +# headertype = [0x49, 0x48, 0x44, 0x52] +# f << headertype +# +# # Width, height, compression, filter, interlacing +# headerdata = ByteWriter.to_bytes(self.width). +# concat(ByteWriter.to_bytes(self.height)). +# concat([0x08, 0x06, 0x00, 0x00, 0x00]) +# f << headerdata +# +# # CRC32 checksum +# sum = headertype.concat(headerdata) +# f.write_int Zlib::crc32(sum.pack("C*")) +# +# #============================== Writing data ================================# +# data = [] +# for y in 0...self.height +# # Start scanline +# data << 0x00 # Filter: None +# for x in 0...self.width +# px = self.get_pixel(x, y) +# # Write raw RGBA pixels +# data << px.red +# data << px.green +# data << px.blue +# data << px.alpha +# end +# end +# # Zlib deflation +# smoldata = Zlib::Deflate.deflate(data.pack("C*")).bytes.map +# # data chunk length +# f.write_int smoldata.size +# # IDAT +# f << [0x49, 0x44, 0x41, 0x54] +# f << smoldata +# # CRC32 checksum +# f.write_int Zlib::crc32([0x49, 0x44, 0x41, 0x54].concat(smoldata).pack("C*")) +# +# #============================== End Of File =================================# +# # Empty chunk +# f << [0x00, 0x00, 0x00, 0x00] +# # IEND +# f << [0x49, 0x45, 0x4E, 0x44] +# # CRC32 checksum +# f.write_int Zlib::crc32([0x49, 0x45, 0x4E, 0x44].pack("C*")) +# f.close +# return nil +# end +# end + + +# Stand-alone methods + +# Fades in a black overlay +def showBlk(n = 16) + return if $blkVp || $blk + $blkVp = Viewport.new(0,0,Settings::SCREEN_WIDTH,Settings::SCREEN_HEIGHT) + $blkVp.z = 9999999 + $blk = Sprite.new($blkVp) + $blk.bmp(-1,-1) + $blk.bitmap.fill_rect(0,0,Settings::SCREEN_WIDTH,Settings::SCREEN_HEIGHT,Color.new(0,0,0)) + $blk.opacity = 0 + for i in 0...(n + 1) + Graphics.update + Input.update + yield i if block_given? + $blk.opacity += 256 / n.to_f + end +end + +# Fades out and disposes a black overlay +def hideBlk(n = 16) + return if !$blk || !$blkVp + for i in 0...(n + 1) + Graphics.update + Input.update + yield i if block_given? + $blk.opacity -= 256 / n.to_f + end + $blk.dispose + $blk = nil + $blkVp.dispose + $blkVp = nil +end + +# Returns the percentage of exp the Pokémon has compared to the next level +# def pbGetE +# xpPercentage(pokemon) +# pokemon = pokemon.pokemon if pokemon.respond_to?("pokemon") +# startexp = PBExperience.pbGetStartExperience(pokemon.level, pokemon.growthrate) +# endexp = PBExperience.pbGetStartExperience(pokemon.level + 1, pokemon.growthrate) +# return (pokemon.exp - startexp).to_f / (endexp - startexp).to_f +# end + +# unless defined?(oldrand) +# alias oldrand rand +# def rand(a = nil, b = nil) +# if a.is_a?(Range) +# l = a.min +# u = a.max +# return l + oldrand(u - l + 1) +# elsif a.is_a?(Numeric) +# if b.is_a?(Numeric) +# return a + oldrand(b - a) +# else +# return oldrand(a) +# end +# elsif a.nil? +# if b +# return rand(b) +# else +# return oldrand(2) +# end +# end +# end +# end + +# Input module extensions +# module Input +# # Returns true if any of the buttons below are pressed +# def self.any? +# return true if defined?(Game_Mouse) && $mouse && $mouse.click? +# keys = [Input::C,Input::B,Input::LEFT,Input::RIGHT,Input::UP,Input::DOWN, +# # 0-9, a-z +# 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44, +# 0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x50,0x51,0x52,0x53, +# 0x54,0x55,0x56,0x57,0x58,0x59,0x5A] +# for key in keys +# return true if Input.triggerex?(key) +# end +# return false +# end +# end + + + + +# +# if SPECIAL_ERRORS +# +# MessageBox = Win32API.new('user32', 'MessageBox', ['I','P','P','I'], 'I') +# +# def p_msg(msg, title = nil, icon = nil) +# case icon +# when :error, :err +# uType = 0x10 +# title ||= "Error" +# when :q, :question, :ask +# uType = 0x20 +# title ||= "Question" +# when :warning, :warn +# uType = 0x30 +# title ||= "Warning" +# when :inform, :info, :information +# uType = 0x40 +# title ||= "Info" +# else +# uType = 0 +# title ||= "Pokémon" +# end +# hwnd = Win32API.pbFindRgssWindow +# Graphics.update +# t = Thread.new { MessageBox.call(hwnd, msg, title, uType); Thread.exit } +# while t.status +# Graphics.update +# end +# end +# +# def p_err(ex = $!, message = nil) +# if $Rescue +# raise +# return +# end +# if ex.is_a?(String) +# ex = RuntimeError.new ex +# elsif ex.is_a?(Class) +# ex = ex.new +# end +# trace = ex.backtrace || caller +# script_id = trace[0][7..-1].split(':')[0].to_i +# script = $RGSS_SCRIPTS[script_id][1] +# line = trace[0].split(':')[1].to_i +# msg = "Script '[#{script}]' line #{line}: #{ex.class} occurred." +# if message || ex.message != ex.class.to_s +# if message +# msg << "\n\n#{message}" +# else +# msg << "\n\n#{ex.message}" +# message = ex.message +# end +# end +# showtrace = (trace.size > 2) +# showtrace = false if !DOUBLE_BACKTRACE && message.include?(':in `') +# if showtrace +# msg << "\n\n" +# msg << trace[0...BACKTRACE_MAX_SIZE].map do |e| +# sID = e.split(':')[0][7..-1] +# if sID && sID.numeric? +# sID = sID.to_i +# s = "'" + $RGSS_SCRIPTS[sID][1] + "'" +# else +# s = "eval" +# end +# line = e.split(':')[1].to_i +# code = e.split(':')[2..-1].join(':') +# str = "from #{s} line #{line}" +# str << " #{code}" unless code.empty? +# next str +# end.join("\n") +# end +# p_msg(msg, "Error", :err) +# Kernel.exit! true +# end +# +# def p_info(msg, title = nil) +# p_msg(msg, title, :info) +# end +# +# def p_warn(msg, title = nil) +# p_msg(msg, title, :warn) +# end +# +# def p_question(msg, title = nil) +# p_msg(msg, title, :question) +# end +# +# trace_var(:$scene, proc do |object| +# break unless object +# unless object.instance_variable_get(:@__old_main) +# object.instance_variable_set(:@__old_main, object.method(:main)) +# def object.main +# self.instance_variable_get(:@__old_main).call +# rescue +# p_err +# end +# end +# end) +# +# else +# +# def p_err(*args) +# raise *args +# end +# +# end # if SPECIAL_ERRORS + + +# def pbGetActiveEventPage(event, mapid = nil) +# mapid ||= event.map.map_id if event.respond_to?(:map) +# pages = (event.is_a?(RPG::Event) ? event.pages : event.instance_eval { @event.pages }) +# for i in 0...pages.size +# c = pages[pages.size - 1 - i].condition +# ss = !(c.self_switch_valid && !$game_self_switches[[mapid, +# event.id,c.self_switch_ch]]) +# sw1 = !(c.switch1_valid && !$game_switches[c.switch1_id]) +# sw2 = !(c.switch2_valid && !$game_switches[c.switch2_id]) +# var = true +# if c.variable_valid +# if !c.variable_value || !$game_variables[c.variable_id].is_a?(Numeric) || +# $game_variables[c.variable_id] < c.variable_value +# var = false +# end +# end +# if ss && sw1 && sw2 && var # All conditions are met +# return pages[pages.size - 1 - i] +# end +# end +# return nil +# end \ No newline at end of file diff --git a/Data/Scripts/050_AddOns/BattleLounge.rb b/Data/Scripts/050_AddOns/BattleLounge.rb index 43676ccdd..997e412b4 100644 --- a/Data/Scripts/050_AddOns/BattleLounge.rb +++ b/Data/Scripts/050_AddOns/BattleLounge.rb @@ -27,17 +27,17 @@ def get_egg_group_name(id) case id when 0 ;return nil when 1;return "Monster Pokémon" - when 2;return :"Water Pokémon" + when 2;return :"Aquatic Pokémon" when 3;return :"Bug Pokémon" when 4;return :"Bird Pokémon" when 5;return :"Land Pokémon" when 6;return :"Cute Pokémon" when 7;return :"Plant Pokémon" when 8;return :"Human-like Pokémon" - when 9;return :"Water Pokémon" + when 9;return :"Aquatic Pokémon" when 10;return :"Mineral Pokémon" when 11;return :"Blob Pokémon" - when 12;return :"Water Pokémon" + when 12;return :"Fish Pokémon" when 13;return :"Ditto" when 14;return :"Dragon Pokémon" when 15;return :"Legendary Pokémon" diff --git a/Data/Scripts/050_AddOns/BetterRegionMap.rb b/Data/Scripts/050_AddOns/BetterRegionMap.rb index 30ee2d991..930e9da8c 100644 --- a/Data/Scripts/050_AddOns/BetterRegionMap.rb +++ b/Data/Scripts/050_AddOns/BetterRegionMap.rb @@ -1,9 +1,6 @@ -=begin - - #==============================================================================# # Better Region Map # -# by Marin # +# By Marin, with edits by Boonzeet # #==============================================================================# # This region map is smoother and allows you to use region maps larger than # # 480x320. # @@ -11,34 +8,33 @@ # This resource also comes with a new townmapgen.html to support for the # # larger images. # #==============================================================================# -# This region map does NOT support hidden islands such as Berth or Faraday. # +# This region map now supports hidden islands (e.g. Berth or Faraday). # #==============================================================================# # Please give credit when using this. # #==============================================================================# +# +# PluginManager.register({ +# :name => "Better Region Map", +# :version => "1.2", +# :credits => ["Marin", "Boonzeet"], +# :dependencies => "Marin's Scripting Utilities", +# :link => "https://reliccastle.com/resources/174/" +# }) -def pbBetterRegionMap(region = nil, show_player = true, can_fly = false) - - if region == nil - mapData = pbGetMetadata($game_map.map_id,MetadataMapPosition) - if mapData != nil && mapData.length >= 1 - region = mapData[0] - else - region = 0 - end - end - scene = BetterRegionMap.new(region, show_player, can_fly) +def pbBetterRegionMap(region = -1, show_player = true, can_fly = false, wallmap = false, species = nil,fly_anywhere=false) + scene = BetterRegionMap.new(region, show_player, can_fly, wallmap, species,fly_anywhere) return scene.flydata end class PokemonGlobalMetadata attr_writer :regionMapSel attr_writer :region - + def regionMapSel @regionMapSel ||= [0, 0] return @regionMapSel end - + def region @region ||= 0 return @region @@ -47,54 +43,60 @@ end class BetterRegionMap CursorAnimateDelay = 12.0 - CursorMoveSpeed = 4 + CursorMoveSpeed = 4.0 TileWidth = 16.0 TileHeight = 16.0 - MAP_MARGIN = 10 FlyPointAnimateDelay = 20.0 - - attr_reader :flydata - - def initialize(region = nil, show_player = true, can_fly = false) - showBlk() - @region = 0#region || $PokemonGlobal.region - @show_player = show_player - @can_fly = can_fly - @data = load_data('Data/townmap.dat')[@region] - @viewport = Viewport.new(0,0,Graphics.width,Graphics.height) - @viewport.z = 99999 - @mapvp = Viewport.new(16,32,480,320) + attr_reader :flydata + + def initialize(region = -1, show_player = true, can_fly = false, wallmap = false, species = nil,fly_anywhere=false) + showBlk + map_metadata = GameData::MapMetadata.try_get($game_map.map_id) + playerpos = $game_map ? map_metadata.town_map_position : nil#pbGetMetadata($game_map.map_id, MetadataMapPosition) : nil + if playerpos == nil + playerpos = [0,0] + end + @fly_anywhere = fly_anywhere + @region = (region < 0) ? playerpos[0] : region + @species = species + @show_player = (show_player && playerpos[0] == @region) + @can_fly = can_fly + @data = load_data("Data/town_map.dat")[@region] + @viewport = Viewport.new(0, 0, Graphics.width, Graphics.height) + @viewport.z = 99999 + @mapdata = pbLoadTownMapData + @mapvp = Viewport.new(16, 32, 480, 320) @mapvp.z = 100000 - @viewport2 = Viewport.new(0,0,Graphics.width,Graphics.height) + @mapoverlayvp = Viewport.new(16,32,480,320) + @mapoverlayvp.z = 100001 + @viewport2 = Viewport.new(0, 0, Graphics.width, Graphics.height) @viewport2.z = 100001 @sprites = SpriteHash.new @sprites["bg"] = Sprite.new(@viewport) @sprites["bg"].bmp("Graphics/Pictures/mapbg") @window = SpriteHash.new - @window["map"] = Sprite.new(@mapvp) @window["map"].bmp("Graphics/Pictures/#{@data[1]}") - - - @sprites["cursor"] = Sprite.new(@viewport2) - @sprites["cursor"].bmp("Graphics/Pictures/mapCursor") - @sprites["cursor"].src_rect.width = @sprites["cursor"].bmp.height - @sprites["cursor"].x = 16 + TileWidth * $PokemonGlobal.regionMapSel[0] - @sprites["cursor"].y = 32 + TileHeight * $PokemonGlobal.regionMapSel[1] - - @sprites["cursor"].z = 11 - @sprites["cursor"].ox = (@sprites["cursor"].bmp.height - TileWidth) / 2.0 - @sprites["cursor"].oy = @sprites["cursor"].ox - - - @window["player"] = Sprite.new(@mapvp) - + # for hidden in REGION_MAP_EXTRAS + # if hidden[0] == @region && ((wallmap && hidden[5]) || # always show if looking at wall map, irrespective of switch + # (!wallmap && hidden[1] > 0 && $game_switches[hidden[1]])) + # if !@window["map2"] + # @window["map2"] = BitmapSprite.new(480,320,@mapoverlayvp) + # end + # pbDrawImagePositions(@window["map2"].bitmap, [ + # ["Graphics/Pictures/#{hidden[4]}", hidden[2] * TileWidth, hidden[3] * TileHeight, 0, 0, -1, -1], + # ]) + # end + # end + @window["player"] = Sprite.new(@mapoverlayvp) if @show_player player = nil - player = pbGetMetadata($game_map.map_id, MetadataMapPosition) if $game_map + player = GameData::MapMetadata.get($game_map.map_id).town_map_position #pbGetMetadata($game_map.map_id, MetadataMapPosition) if $game_map if player && player[0] == @region + $PokemonGlobal.regionMapSel[0] = player[1] + $PokemonGlobal.regionMapSel[1] = player[2] gender = $Trainer.gender.to_digits(3) @window["player"].bmp("Graphics/Pictures/mapPlayer#{gender}") @window["player"].x = TileWidth * player[1] + (TileWidth / 2.0) @@ -102,6 +104,89 @@ class BetterRegionMap @window["player"].center_origins end end + @window["areahighlight"] = BitmapSprite.new(@window["map"].bitmap.width,@window["map"].bitmap.height,@mapoverlayvp) + @window["areahighlight"].y = -8 + # pokedex highlights + if @species != nil + @window["areahighlight"].bitmap.clear + # Fill the array "points" with all squares of the region map in which the + # species can be found + + mapwidth = @window["map"].bitmap.width/BetterRegionMap::TileWidth + data = calculatePointsAndCenter(mapwidth) + + points = data[0] + minxy = data[1] + maxxy = data[2] + + # Draw coloured squares on each square of the region map with a nest + pointcolor = Color.new(0,248,248) + pointcolorhl = Color.new(192,248,248) + + sqwidth = TileWidth.round + sqheight = TileHeight.round + + for j in 0...points.length + if points[j] + x = (j % mapwidth) * sqwidth + y = (j / mapwidth) * sqheight + @window["areahighlight"].bitmap.fill_rect(x, y, sqwidth, sqheight, pointcolor) + if j - mapwidth < 0 || !points[j - mapwidth] + @window["areahighlight"].bitmap.fill_rect(x, y - 2, sqwidth, 2, pointcolorhl) + end + if j + mapwidth >= points.length || !points[j + mapwidth] + @window["areahighlight"].bitmap.fill_rect(x, y + sqheight, sqwidth, 2, pointcolorhl) + end + if j % mapwidth == 0 || !points[j - 1] + @window["areahighlight"].bitmap.fill_rect(x - 2, y, 2, sqheight, pointcolorhl) + end + if (j + 1) % mapwidth == 0 || !points[j + 1] + @window["areahighlight"].bitmap.fill_rect(x + sqwidth, y, 2, sqheight, pointcolorhl) + end + end + end + end + + @sprites["cursor"] = Sprite.new(@viewport2) + @sprites["cursor"].bmp("Graphics/Pictures/mapCursor") + @sprites["cursor"].src_rect.width = @sprites["cursor"].bmp.height + + if !$PokemonGlobal.regionMapSel + $PokemonGlobal.regionMapSel = [0,0] + end + if @species != nil && minxy[0] != nil && maxxy[1] != nil + $PokemonGlobal.regionMapSel[0] = ((minxy[0] + maxxy[0]) / 2).round + $PokemonGlobal.regionMapSel[1] = ((minxy[1] + maxxy[1]) / 2).round + end + + @sprites["cursor"].x = 16 + TileWidth * $PokemonGlobal.regionMapSel[0] + @sprites["cursor"].y = 32 + TileHeight * $PokemonGlobal.regionMapSel[1] + + @sprites["cursor"].z = 11 + + # Center the window on the cursor + windowminx = -1 * (@window["map"].bmp.width - Settings::SCREEN_WIDTH) + windowminx = 0 if windowminx > 0 + windowminy = -1 * (@window["map"].bmp.height - Settings::SCREEN_HEIGHT) + windowminy = 0 if windowminy > 0 + + if @sprites["cursor"].x > (Settings::SCREEN_WIDTH / 2) + @window.x = (Settings::SCREEN_WIDTH / 2 ) - @sprites["cursor"].x + if (@window.x < windowminx) + @window.x = windowminx + end + @sprites["cursor"].x += @window.x + end + if @sprites["cursor"].y > (Settings::SCREEN_HEIGHT / 2) + @window.y = (Settings::SCREEN_HEIGHT / 2 ) - @sprites["cursor"].y + if @window.y < windowminy + @window.y = windowminy + end + @sprites["cursor"].y += @window.y + end + + @sprites["cursor"].ox = (@sprites["cursor"].bmp.height - TileWidth) / 2.0 + @sprites["cursor"].oy = @sprites["cursor"].ox @sprites["txt"] = TextSprite.new(@viewport) @sprites["arrowLeft"] = Sprite.new(@viewport2) @sprites["arrowLeft"].bmp("Graphics/Pictures/mapArrowRight") @@ -121,18 +206,19 @@ class BetterRegionMap @sprites["arrowDown"].bmp("Graphics/Pictures/mapArrowDown") @sprites["arrowDown"].center_origins @sprites["arrowDown"].xyz = Graphics.width / 2, Graphics.height - 24 + update_text @dirs = [] @mdirs = [] @i = 0 - + if can_fly @spots = {} n = 0 for x in 0...(@window["map"].bmp.width / TileWidth) for y in 0...(@window["map"].bmp.height / TileHeight) - healspot = pbGetHealingSpot(x,y) - if healspot && $PokemonGlobal.visitedMaps[healspot[0]] + healspot = pbGetHealingSpot(x, y) + if can_fly_to_location(healspot) @window["point#{n}"] = Sprite.new(@mapvp) @window["point#{n}"].bmp("Graphics/Pictures/mapFly") @window["point#{n}"].src_rect.width = @window["point#{n}"].bmp.height @@ -146,64 +232,34 @@ class BetterRegionMap end end end - - initWindowPosition(region) - #if region == nil - #end - hideBlk { update(false) } main end - - def initWindowPosition(region=0) - x, y = 0 - if region == 2 #sevii islands - x=-250 - y=-200 - elsif region == 1 #johto - x=0 - y=0 - else #kanto - x=-250 - y=0 - end - updateWindowPosition(x,y) + + def can_fly_to_location(healspot) + return true if healspot && @fly_anywhere + return healspot && $PokemonGlobal.visitedMaps[healspot[0]] end - - #@hor_count = position du pointer - def updateWindowPosition(x,y) - @window.x = x - @window.y = y - - # @hor_count = 0#x - # @ver_count = 0#y - - @sprites["cursor"].x = 16 + TileWidth * $PokemonGlobal.regionMapSel[0] + @window.x - @sprites["cursor"].y = 32 + TileWidth * $PokemonGlobal.regionMapSel[1] + @window.y - - - end - - def pbGetHealingSpot(x,y) + def pbGetHealingSpot(x, y) return nil if !@data[2] for loc in @data[2] if loc[0] == x && loc[1] == y if !loc[4] || !loc[5] || !loc[6] return nil else - return [loc[4],loc[5],loc[6]] + return [loc[4], loc[5], loc[6]] end end end return nil end - + def main loop do update - if Input.press?(Input::RIGHT) && ![4,6].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } + if Input.press?(Input::RIGHT) && ![4, 6].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } if @sprites["cursor"].x < 480 $PokemonGlobal.regionMapSel[0] += 1 @sx = @sprites["cursor"].x @@ -214,7 +270,7 @@ class BetterRegionMap @mdirs << 6 end end - if Input.press?(Input::LEFT) && ![4,6].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } + if Input.press?(Input::LEFT) && ![4, 6].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } if @sprites["cursor"].x > 16 $PokemonGlobal.regionMapSel[0] -= 1 @sx = @sprites["cursor"].x @@ -225,19 +281,18 @@ class BetterRegionMap @mdirs << 4 end end - if Input.press?(Input::DOWN) && ![2,8].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } + if Input.press?(Input::DOWN) && ![2, 8].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } if @sprites["cursor"].y <= 320 $PokemonGlobal.regionMapSel[1] += 1 @sy = @sprites["cursor"].y @dirs << 2 - elsif @window.y > -1 * (@window["map"].bmp.height - 320) $PokemonGlobal.regionMapSel[1] += 1 @my = @window.y @mdirs << 2 end end - if Input.press?(Input::UP) && ![2,8].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } + if Input.press?(Input::UP) && ![2, 8].any? { |e| @dirs.include?(e) || @mdirs.include?(e) } if @sprites["cursor"].y > 32 $PokemonGlobal.regionMapSel[1] -= 1 @sy = @sprites["cursor"].y @@ -259,18 +314,22 @@ class BetterRegionMap end dispose end - + def update(update_gfx = true) - @sprites["arrowLeft"].visible = @window.x < 0 -MAP_MARGIN - @sprites["arrowRight"].visible = @window.x > -1 * (@window["map"].bmp.width - 480) +MAP_MARGIN - @sprites["arrowUp"].visible = @window.y < 0 - MAP_MARGIN - @sprites["arrowDown"].visible = @window.y > -1 * (@window["map"].bmp.height - 320) +MAP_MARGIN - + @sprites["arrowLeft"].visible = @window.x < 0 + @sprites["arrowRight"].visible = @window.x > -1 * (@window["map"].bmp.width - 480) + @sprites["arrowUp"].visible = @window.y < 0 + @sprites["arrowDown"].visible = @window.y > -1 * (@window["map"].bmp.height - 320) + if update_gfx Graphics.update Input.update end - + + intensity = (Graphics.frame_count % 40) * 12 + intensity = 480 - intensity if intensity > 240 + @window["areahighlight"].opacity = intensity + @i += 1 if @i % CursorAnimateDelay == 0 @sprites["cursor"].src_rect.x += @sprites["cursor"].src_rect.width @@ -278,12 +337,12 @@ class BetterRegionMap end if @i % FlyPointAnimateDelay == 0 @window.keys.each do |e| - next unless e.to_s.starts_with?("point") + next unless e.to_s.start_with?("point") @window[e].src_rect.x += @window[e].src_rect.width @window[e].src_rect.x = 0 if @window[e].src_rect.x >= @window[e].bmp.width end end - + if @i % 2 == 0 case @i % 32 when 0...8 @@ -303,7 +362,7 @@ class BetterRegionMap @sprites["arrowDown"].y += 1 end end - + # Cursor movement if @dirs.include?(6) @hor_count ||= 0 @@ -349,7 +408,7 @@ class BetterRegionMap @sy = nil end end - + # Map movement if @mdirs.include?(6) @hor_count ||= 0 @@ -396,24 +455,24 @@ class BetterRegionMap end end end - + def update_text location = @data[2].find do |e| e[0] == $PokemonGlobal.regionMapSel[0] && - e[1] == $PokemonGlobal.regionMapSel[1] + e[1] == $PokemonGlobal.regionMapSel[1] end text = "" text = location[2] if location poi = "" poi = location[3] if location && location[3] @sprites["txt"].draw([ - [pbGetMessage(MessageTypes::RegionNames,@region), 16, 0, 0, - Color.new(255,255,255), Color.new(0,0,0)], - [text, 16, 354, 0, Color.new(255,255,255), Color.new(0,0,0)], - [poi, 496, 354, 1, Color.new(255,255,255), Color.new(0,0,0)] - ], true) + [pbGetMessage(MessageTypes::RegionNames, @region), 16, 0, 0, + Color.new(255, 255, 255), Color.new(0, 0, 0)], + [text, 16, 354, 0, Color.new(255, 255, 255), Color.new(0, 0, 0)], + [poi, 496, 354, 1, Color.new(255, 255, 255), Color.new(0, 0, 0)], + ], true) end - + def dispose showBlk { update(false) } @sprites.dispose @@ -430,20 +489,24 @@ end # Overwrites some old methods to use the new region map # #==============================================================================# -#ItemHandlers::UseInField.add(:TOWNMAP,proc{|item| -# pbBetterRegionMap -# next 1 -#}) +ItemHandlers::UseInField.add(:TOWNMAP, proc { |item| + pbBetterRegionMap + next 1 +}) + +def pbShowMap(region = -1, wallmap = true) # pokegear +pbBetterRegionMap(region, true, false, wallmap) +end class PokemonPartyScreen def pbPokemonScreen @scene.pbStartScene(@party, - (@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."),nil) + (@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel."), nil) loop do @scene.pbSetHelpText((@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel.")) pkmnid = @scene.pbChoosePokemon(false, -1, 1) break if (pkmnid.is_a?(Numeric) && pkmnid < 0) || (pkmnid.is_a?(Array) && pkmnid[1] < 0) - if pkmnid.is_a?(Array) && pkmnid[0] == 1 # Switch + if pkmnid.is_a?(Array) && pkmnid[0] == 1 # Switch @scene.pbSetHelpText(_INTL("Move to where?")) oldpkmnid = pkmnid[1] pkmnid = @scene.pbChoosePokemon(true, -1, 2) @@ -453,42 +516,42 @@ class PokemonPartyScreen next end pkmn = @party[pkmnid] - commands = [] + commands = [] cmdSummary = -1 - cmdDebug = -1 - cmdMoves = [-1,-1,-1,-1] - cmdSwitch = -1 - cmdMail = -1 - cmdItem = -1 + cmdDebug = -1 + cmdMoves = [-1, -1, -1, -1] + cmdSwitch = -1 + cmdMail = -1 + cmdItem = -1 # Build the commands - commands[cmdSummary = commands.length] = _INTL("Summary") - commands[cmdDebug = commands.length] = _INTL("Debug") if $DEBUG + commands[cmdSummary = commands.length] = _INTL("Summary") + commands[cmdDebug = commands.length] = _INTL("Debug") if $DEBUG for i in 0...pkmn.moves.length move = pkmn.moves[i] # Check for hidden moves and add any that were found - if !pkmn.egg? && (isConst?(move.id,PBMoves,:MILKDRINK) || - isConst?(move.id,PBMoves,:SOFTBOILED) || - HiddenMoveHandlers.hasHandler(move.id)) - commands[cmdMoves[i] = commands.length] = [PBMoves.getName(move.id),1] + if !pkmn.egg? && (isConst?(move.id, PBMoves, :MILKDRINK) || + isConst?(move.id, PBMoves, :SOFTBOILED) || + HiddenMoveHandlers.hasHandler(move.id)) + commands[cmdMoves[i] = commands.length] = [PBMoves.getName(move.id), 1] end end - commands[cmdSwitch = commands.length] = _INTL("Switch") if @party.length>1 + commands[cmdSwitch = commands.length] = _INTL("Switch") if @party.length > 1 if !pkmn.egg? if pkmn.mail - commands[cmdMail = commands.length] = _INTL("Mail") + commands[cmdMail = commands.length] = _INTL("Mail") else - commands[cmdItem = commands.length] = _INTL("Item") + commands[cmdItem = commands.length] = _INTL("Item") end end - commands[commands.length] = _INTL("Cancel") - command = @scene.pbShowCommands(_INTL("Do what with {1}?",pkmn.name),commands) + commands[commands.length] = _INTL("Cancel") + command = @scene.pbShowCommands(_INTL("Do what with {1}?", pkmn.name), commands) havecommand = false for i in 0...4 if cmdMoves[i] >= 0 && command == cmdMoves[i] havecommand = true - if isConst?(pkmn.moves[i].id,PBMoves,:SOFTBOILED) || - isConst?(pkmn.moves[i].id,PBMoves,:MILKDRINK) - amt = [(pkmn.totalhp/5).floor,1].max + if isConst?(pkmn.moves[i].id, PBMoves, :SOFTBOILED) || + isConst?(pkmn.moves[i].id, PBMoves, :MILKDRINK) + amt = [(pkmn.totalhp / 5).floor, 1].max if pkmn.hp <= amt pbDisplay(_INTL("Not enough HP...")) break @@ -502,15 +565,15 @@ class PokemonPartyScreen newpkmn = @party[pkmnid] movename = PBMoves.getName(pkmn.moves[i].id) if pkmnid == oldpkmnid - pbDisplay(_INTL("{1} can't use {2} on itself!",pkmn.name,movename)) + pbDisplay(_INTL("{1} can't use {2} on itself!", pkmn.name, movename)) elsif newpkmn.egg? - pbDisplay(_INTL("{1} can't be used on an Egg!",movename)) + pbDisplay(_INTL("{1} can't be used on an Egg!", movename)) elsif newpkmn.hp == 0 || newpkmn.hp == newpkmn.totalhp - pbDisplay(_INTL("{1} can't be used on that Pokémon.",movename)) + pbDisplay(_INTL("{1} can't be used on that Pokémon.", movename)) else pkmn.hp -= amt - hpgain = pbItemRestoreHP(newpkmn,amt) - @scene.pbDisplay(_INTL("{1}'s HP was restored by {2} points.",newpkmn.name,hpgain)) + hpgain = pbItemRestoreHP(newpkmn, amt) + @scene.pbDisplay(_INTL("{1}'s HP was restored by {2} points.", newpkmn.name, hpgain)) pbRefresh end break if pkmn.hp <= amt @@ -518,22 +581,22 @@ class PokemonPartyScreen @scene.pbSelect(oldpkmnid) pbRefresh break - elsif Kernel.pbCanUseHiddenMove?(pkmn,pkmn.moves[i].id) - if Kernel.pbConfirmUseHiddenMove(pkmn,pkmn.moves[i].id) + elsif Kernel.pbCanUseHiddenMove?(pkmn, pkmn.moves[i].id) + if Kernel.pbConfirmUseHiddenMove(pkmn, pkmn.moves[i].id) @scene.pbEndScene - if isConst?(pkmn.moves[i].id,PBMoves,:FLY) + if isConst?(pkmn.moves[i].id, PBMoves, :FLY) ############################################### - ret = pbBetterRegionMap(nil, true, true) + ret = pbBetterRegionMap(-1, true, true) if ret $PokemonTemp.flydata = ret - return [pkmn,pkmn.moves[i].id] + return [pkmn, pkmn.moves[i].id] end @scene.pbStartScene(@party, - (@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel.")) + (@party.length > 1) ? _INTL("Choose a Pokémon.") : _INTL("Choose Pokémon or cancel.")) break ############################################### end - return [pkmn,pkmn.moves[i].id] + return [pkmn, pkmn.moves[i].id] end else break @@ -544,7 +607,7 @@ class PokemonPartyScreen if cmdSummary >= 0 && command == cmdSummary @scene.pbSummary(pkmnid) elsif cmdDebug >= 0 && command == cmdDebug - pbPokemonDebug(pkmn,pkmnid) + pbPokemonDebug(pkmn, pkmnid) elsif cmdSwitch >= 0 && command == cmdSwitch @scene.pbSetHelpText(_INTL("Move to where?")) oldpkmnid = pkmnid @@ -554,10 +617,10 @@ class PokemonPartyScreen end elsif cmdMail >= 0 && command == cmdMail command = @scene.pbShowCommands(_INTL("Do what with the mail?"), - [_INTL("Read"),_INTL("Take"),_INTL("Cancel")]) + [_INTL("Read"), _INTL("Take"), _INTL("Cancel")]) case command when 0 # Read - pbFadeOutIn(99999){ pbDisplayMail(pkmn.mail,pkmn) } + pbFadeOutIn(99999) { pbDisplayMail(pkmn.mail, pkmn) } when 1 # Take if pbTakeItemFromPokemon(pkmn, self) pbRefreshSingle(pkmnid) @@ -565,38 +628,38 @@ class PokemonPartyScreen end elsif cmdItem >= 0 && command == cmdItem itemcommands = [] - cmdUseItem = -1 - cmdGiveItem = -1 - cmdTakeItem = -1 - cmdMoveItem = -1 + cmdUseItem = -1 + cmdGiveItem = -1 + cmdTakeItem = -1 + cmdMoveItem = -1 # Build the commands - itemcommands[cmdUseItem=itemcommands.length] = _INTL("Use") - itemcommands[cmdGiveItem=itemcommands.length] = _INTL("Give") - itemcommands[cmdTakeItem=itemcommands.length] = _INTL("Take") if pkmn.hasItem? - itemcommands[cmdMoveItem=itemcommands.length] = _INTL("Move") if pkmn.hasItem? && !pbIsMail?(pkmn.item) - itemcommands[itemcommands.length] = _INTL("Cancel") - command = @scene.pbShowCommands(_INTL("Do what with an item?"),itemcommands) - if cmdUseItem >= 0 && command == cmdUseItem # Use + itemcommands[cmdUseItem = itemcommands.length] = _INTL("Use") + itemcommands[cmdGiveItem = itemcommands.length] = _INTL("Give") + itemcommands[cmdTakeItem = itemcommands.length] = _INTL("Take") if pkmn.hasItem? + itemcommands[cmdMoveItem = itemcommands.length] = _INTL("Move") if pkmn.hasItem? && !pbIsMail?(pkmn.item) + itemcommands[itemcommands.length] = _INTL("Cancel") + command = @scene.pbShowCommands(_INTL("Do what with an item?"), itemcommands) + if cmdUseItem >= 0 && command == cmdUseItem # Use item = @scene.pbUseItem($PokemonBag, pkmn) - if item>0 - pbUseItemOnPokemon(item,pkmn,self) + if item > 0 + pbUseItemOnPokemon(item, pkmn, self) pbRefreshSingle(pkmnid) end - elsif cmdGiveItem >= 0 && command == cmdGiveItem # Give + elsif cmdGiveItem >= 0 && command == cmdGiveItem # Give item = @scene.pbChooseItem($PokemonBag) if item > 0 if pbGiveItemToPokemon(item, pkmn, self, pkmnid) pbRefreshSingle(pkmnid) end end - elsif cmdTakeItem >= 0 && command == cmdTakeItem # Take + elsif cmdTakeItem >= 0 && command == cmdTakeItem # Take if pbTakeItemFromPokemon(pkmn, self) pbRefreshSingle(pkmnid) end - elsif cmdMoveItem >= 0 && command == cmdMoveItem # Move + elsif cmdMoveItem >= 0 && command == cmdMoveItem # Move item = pkmn.item itemname = PBItems.getName(item) - @scene.pbSetHelpText(_INTL("Move {1} to where?",itemname)) + @scene.pbSetHelpText(_INTL("Move {1} to where?", itemname)) oldpkmnid = pkmnid loop do @scene.pbPreSelect(oldpkmnid) @@ -612,27 +675,27 @@ class PokemonPartyScreen pkmn.setItem(0) @scene.pbClearSwitching pbRefresh - pbDisplay(_INTL("{1} was given the {2} to hold.",newpkmn.name,itemname)) + pbDisplay(_INTL("{1} was given the {2} to hold.", newpkmn.name, itemname)) break elsif pbIsMail?(newpkmn.item) - pbDisplay(_INTL("{1}'s mail must be removed before giving it an item.",newpkmn.name)) + pbDisplay(_INTL("{1}'s mail must be removed before giving it an item.", newpkmn.name)) else newitem = newpkmn.item newitemname = PBItems.getName(newitem) - if isConst?(newitem,PBItems,:LEFTOVERS) - pbDisplay(_INTL("{1} is already holding some {2}.\1",newpkmn.name,newitemname)) - elsif ['a','e','i','o','u'].include?(newitemname[0,1].downcase) - pbDisplay(_INTL("{1} is already holding an {2}.\1",newpkmn.name,newitemname)) + if isConst?(newitem, PBItems, :LEFTOVERS) + pbDisplay(_INTL("{1} is already holding some {2}.\1", newpkmn.name, newitemname)) + elsif ["a", "e", "i", "o", "u"].include?(newitemname[0, 1].downcase) + pbDisplay(_INTL("{1} is already holding an {2}.\1", newpkmn.name, newitemname)) else - pbDisplay(_INTL("{1} is already holding a {2}.\1",newpkmn.name,newitemname)) + pbDisplay(_INTL("{1} is already holding a {2}.\1", newpkmn.name, newitemname)) end if pbConfirm(_INTL("Would you like to switch the two items?")) newpkmn.setItem(item) pkmn.setItem(newitem) @scene.pbClearSwitching pbRefresh - pbDisplay(_INTL("{1} was given the {2} to hold.",newpkmn.name,itemname)) - pbDisplay(_INTL("{1} was given the {2} to hold.",pkmn.name,newitemname)) + pbDisplay(_INTL("{1} was given the {2} to hold.", newpkmn.name, itemname)) + pbDisplay(_INTL("{1} was given the {2} to hold.", pkmn.name, newitemname)) break end end @@ -642,22 +705,76 @@ class PokemonPartyScreen end @scene.pbEndScene return nil - end + end end +def calculatePointsAndCenter(mapwidth) + # Fill the array "points" with all squares of the region map in which the + # species can be found + points = [] + + encdata = pbLoadEncountersData + + minxy = [nil, nil] # top-leftmost tile + maxxy = [nil, nil] # bottom-rightmost tile + + for enc in encdata.keys + enctypes = encdata[enc][1] + if pbFindEncounter(enctypes, @species) + mappos = GameData::MapMetadata.get(enc).town_map_position + + if mappos && mappos[0] == @region + showpoint = true + for loc in @mapdata[@region][2] + showpoint = false if loc[0] == mappos[1] && loc[1] == mappos[2] && + loc[7] && !$game_switches[loc[7]] + end + if showpoint + #mapsize = pbGetMetadata(enc, MetadataMapSize) + mapsize = GameData::MapMetadata.get(enc).town_map_size + + if mapsize && mapsize[0] && mapsize[0] > 0 + sqwidth = mapsize[0] + sqheight = (mapsize[1].length * 1.0 / mapsize[0]).ceil + for i in 0...sqwidth + for j in 0...sqheight + if mapsize[1][i + j * sqwidth, 1].to_i > 0 + # work out the upper-leftmost and lower-rightmost tiles + minxy[0] = (minxy[0] == nil || minxy[0] > mappos[1]+i) ? mappos[1]+i : minxy[0] + minxy[1] = (minxy[1] == nil || minxy[1] > mappos[2]+j) ? mappos[2]+j : minxy[1] + maxxy[0] = (maxxy[0] == nil || maxxy[0] < mappos[1]+i) ? mappos[1]+i : maxxy[0] + maxxy[1] = (maxxy[1] == nil || maxxy[1] < mappos[2]+j) ? mappos[2]+j : maxxy[1] + points[mappos[1] + i + (mappos[2] + j) * mapwidth] = true + end + end + end + else + # work out the upper-leftmost and lower-rightmost tiles + minxy[0] = (minxy[0] == nil || minxy[0] > mappos[1]) ? mappos[1] : minxy[0] + minxy[1] = minxy[1] == nil || minxy[1] > mappos[2] ? mappos[2] : minxy[1] + maxxy[0] = (maxxy[0] == nil || maxxy[0] < mappos[1]) ? mappos[1] : maxxy[0] + maxxy[1] = (maxxy[1] == nil || maxxy[1] < mappos[2]) ? mappos[2] : maxxy[1] + points[mappos[1] + mappos[2] * mapwidth] = true + end + end + end + end + end + return [points, minxy, maxxy] +end class PokemonReadyMenu - def pbStartReadyMenu(moves,items) + def pbStartReadyMenu(moves, items) commands = [[], []] # Moves, items for i in moves commands[0].push([i[0], PBMoves.getName(i[0]), true, i[1]]) end - commands[0].sort! { |a,b| a[1] <=> b[1] } + commands[0].sort! { |a, b| a[1] <=> b[1] } for i in items commands[1].push([i, PBItems.getName(i), false]) end - commands[1].sort! { |a,b| a[1] <=> b[1] } - + commands[1].sort! { |a, b| a[1] <=> b[1] } + @scene.pbStartScene(commands) loop do command = @scene.pbShowCommands @@ -667,34 +784,34 @@ class PokemonReadyMenu if command[0] == 0 # Use a move move = commands[0][command[1]][0] user = $Trainer.party[commands[0][command[1]][3]] - if isConst?(move,PBMoves,:FLY) + if isConst?(move, PBMoves, :FLY) ############################################### pbHideMenu - ret = pbBetterRegionMap(nil, true, true) + ret = pbBetterRegionMap(-1, true, true) pbShowMenu unless ret ############################################### if ret $PokemonTemp.flydata = ret $game_temp.in_menu = false - Kernel.pbUseHiddenMove(user,move) + Kernel.pbUseHiddenMove(user, move) break end else pbHideMenu - if Kernel.pbConfirmUseHiddenMove(user,move) + if Kernel.pbConfirmUseHiddenMove(user, move) $game_temp.in_menu = false - Kernel.pbUseHiddenMove(user,move) + Kernel.pbUseHiddenMove(user, move) break else pbShowMenu end end else # Use an item - item = commands[1][command[1]][0] - pbHideMenu - if ItemHandlers.triggerConfirmUseInField(item) - break if Kernel.pbUseKeyItemInField(item) - end + item = commands[1][command[1]][0] + pbHideMenu + if ItemHandlers.triggerConfirmUseInField(item) + break if Kernel.pbUseKeyItemInField(item) + end end pbShowMenu end @@ -702,4 +819,164 @@ class PokemonReadyMenu @scene.pbEndScene end end -=end \ No newline at end of file + +class PokemonPokedexInfo_Scene + def drawPageArea + @sprites["background"].setBitmap(_INTL("Graphics/Pictures/Pokedex/bg_area")) + overlay = @sprites["overlay"].bitmap + base = Color.new(88,88,80) + shadow = Color.new(168,184,184) + @sprites["areahighlight"].bitmap.clear + + mapwidth = @sprites["areamap"].bitmap.width/BetterRegionMap::TileWidth + data = calculatePointsAndCenter(mapwidth) + + points = data[0] + minxy = data[1] + maxxy = data[2] + + # Draw coloured squares on each square of the region map with a nest + pointcolor = Color.new(0,248,248) + pointcolorhl = Color.new(192,248,248) + sqwidth = PokemonRegionMap_Scene::SQUAREWIDTH + sqheight = PokemonRegionMap_Scene::SQUAREHEIGHT + + + # Center the window on the center of visible areas + if minxy[0] != nil && maxxy[0] != nil + center_x = ((minxy[0]+maxxy[0])/2).round * sqwidth + center_y = ((minxy[1]+maxxy[1])/2).round * sqheight - 40 + else + center_x = Settings::SCREEN_WIDTH/2 + center_y = Settings::SCREEN_HEIGHT/2 - 40 + end + + windowminx = -1 * (@sprites["areamap"].bmp.width - Settings::SCREEN_WIDTH + 16) + windowminy = -1 * (@sprites["areamap"].bmp.height - Settings::SCREEN_HEIGHT + 16) + + if center_x > (Settings::SCREEN_WIDTH / 2) + @sprites["areamap"].x = (480 / 2 ) - center_x + if (@sprites["areamap"].x < windowminx) + @sprites["areamap"].x = windowminx + end + else + @sprites["areamap"].x = windowminx + end + if center_y > (Settings::SCREEN_HEIGHT / 2) + @sprites["areamap"].y = (320 / 2 ) - center_y + if @sprites["areamap"].y < windowminy + @sprites["areamap"].y = windowminy + end + else + @sprites["areamap"].y = windowminy + end + + for j in 0...points.length + if points[j] + x = (j%mapwidth)*sqwidth + x += @sprites["areamap"].x + y = (j/mapwidth)*sqheight + y += @sprites["areamap"].y - 8 + @sprites["areahighlight"].bitmap.fill_rect(x,y,sqwidth,sqheight,pointcolor) + if j-mapwidth<0 || !points[j-mapwidth] + @sprites["areahighlight"].bitmap.fill_rect(x,y-2,sqwidth,2,pointcolorhl) + end + if j+mapwidth>=points.length || !points[j+mapwidth] + @sprites["areahighlight"].bitmap.fill_rect(x,y+sqheight,sqwidth,2,pointcolorhl) + end + if j%mapwidth==0 || !points[j-1] + @sprites["areahighlight"].bitmap.fill_rect(x-2,y,2,sqheight,pointcolorhl) + end + if (j+1)%mapwidth==0 || !points[j+1] + @sprites["areahighlight"].bitmap.fill_rect(x+sqwidth,y,2,sqheight,pointcolorhl) + end + end + end + + # Set the text + textpos = [] + if points.length==0 + pbDrawImagePositions(overlay,[ + [sprintf("Graphics/Pictures/Pokedex/overlay_areanone"),108,188] + ]) + textpos.push([_INTL("Area unknown"),Graphics.width/2,Graphics.height/2,2,base,shadow]) + end + textpos.push([pbGetMessage(MessageTypes::RegionNames,@region),414,44,2,base,shadow]) + textpos.push([_INTL("{1}'s area",PBSpecies.getName(@species)), + Graphics.width/2,352,2,base,shadow]) + + textpos.push([_INTL("Full view"),Graphics.width/2,306,2,base,shadow]) + pbDrawTextPositions(overlay,textpos) + end +end + +class PokemonPokedexInfo_Scene + def pbScene + pbPlayCrySpecies(@species,@form) + loop do + Graphics.update + Input.update + pbUpdate + dorefresh = false + if Input.trigger?(Input::A) + pbSEStop + pbPlayCrySpecies(@species,@form) if @page==1 + elsif Input.trigger?(Input::B) + pbPlayCloseMenuSE + break + elsif Input.trigger?(Input::C) + if @page==2 # Area + pbBetterRegionMap(@region,false,false,false,@species) + elsif @page==3 # Forms + if @available.length>1 + pbPlayDecisionSE + pbChooseForm + dorefresh = true + end + end + elsif Input.trigger?(Input::UP) + oldindex = @index + pbGoToPrevious + if @index!=oldindex + pbUpdateDummyPokemon + @available = pbGetAvailableForms + pbSEStop + (@page==1) ? pbPlayCrySpecies(@species,@form) : pbPlayCursorSE + dorefresh = true + end + elsif Input.trigger?(Input::DOWN) + oldindex = @index + pbGoToNext + if @index!=oldindex + pbUpdateDummyPokemon + @available = pbGetAvailableForms + pbSEStop + (@page==1) ? pbPlayCrySpecies(@species,@form) : pbPlayCursorSE + dorefresh = true + end + elsif Input.trigger?(Input::LEFT) + oldpage = @page + @page -= 1 + @page = 1 if @page<1 + @page = 3 if @page>3 + if @page!=oldpage + pbPlayCursorSE + dorefresh = true + end + elsif Input.trigger?(Input::RIGHT) + oldpage = @page + @page += 1 + @page = 1 if @page<1 + @page = 3 if @page>3 + if @page!=oldpage + pbPlayCursorSE + dorefresh = true + end + end + if dorefresh + drawPage(@page) + end + end + return @index + end +end \ No newline at end of file