Leon

It is, but requires a specialized script. I believe they may have one at CA.

I loved it personally, but the reason most didnt is the ending, I'd assume. It was very well played, but does get slightly routine after the first 200 hours.

Last night they had a mind-blowing season finale. If you want to see it, go to CBS.com It is well worth it.

All right, so we went over the structure of a class, over a method, etc etc etc... now, it is assignment time. I will ask you just to write a snippet of code and do some vocabulary. Not too hard, eh? Now, here we go: (And please, try this without notes or the other threads before you attempt this.) Vocabulary: method class $global_variable print @@class_variable Constant_Variable The requirements for the code are the following: Make a working class that is called in a 'Call Script' named 'Class_Test' (Don't forget the 'new'!) In the class, there needs to be two methods: initialize and one of any name you wish. In the initialization, define 1 local variable and 2 instance variables, and print hte local variable. In the second method, print the other two instance variables.

Hey, I was curious if anyone here watches this show, other than me. For those who don't know, CSI is a tv drama about a team of crime scene analysts who attempt to solve whatever crime they are assigned to.

All right, boys! Line up! Send me a PM, and I'll send you what needs to be tested. Two Notes: Use 'Z' or 'Shift' to run. if you play excessively in one session, you will notice the weather change, and even time change.

Now, if you have ever done my tutorials from Creation Asylum, you know I started off at a window for the status window. Well, I'm changing things a bit to help with the understanding of how a script works, and for a very simple reason: So you can learn how to correct errors, both syntax errors logical errors. This we'll go over in a few, but first, let's look at how a class works. First, we'll cover a class that is NOT a scene. Scenes work a little differently because of the script 'Main'. But, we'll start with a basic class. Scenes will wait until lesson 2, because they require a few different techniques. A class has simple requirements: A unique name, the initialize method, the end of initialize, and the end of the class. Everything else isn't required at all, granted, without anything else it is useless. The structure is very simple (and always remember to indent!) class Class_Name #This is the same as a constant variable. def initialize #The initialize method, it is always called. If not there, we have a problem... end #To end initialize end #To end the class Sure, this will work, but does nothing without something to make it work. The first command you will learn is print. What this will do is pop up in a window whatever is directly after it, and works as a great debugging tool. For example: class Class_Name #This is the same as a constant variable. def initialize #The initialize method, it is always called. If not there, we have a problem... print "Lizzie" end #To end initialize end #To end the class That code will print the word "Lizze". Now, instead of the word 'print', you can use 'p' and get the same result. Also, believe it or not, you can print variables. But wait, first you must give a variable meaning. Almost everything in scripting deals with variables taht are defined in other locations, but we'll start you off with variables from the same method, then same class, then work on variables from outside the class. To define a variable, you write the variables name For example, an instance variable could be: @variable. To give a variable meaning, we use the equal sign. So to give @variable meaning, we'd do something like this: @variable = 0 Now, @variable equals 0. So whenever we call it, it will always be '0'. And, if we put @variable = 0 above print "Lizzie", then changed "Lizzie" to @variable, it would pop up the number 0. So, the code would look like: class Class_Name #This is the same as a constant variable. def initialize #The initialize method, it is always called. If not there, we have a problem... @variable = 0 #defines @variable print @variable #Prints @variable. end #To end initialize end #To end the class OK, now we have a class with one method, so how do we use more in a class? Well, we define them OUTSIDE of a method, but INSIDE a class. SImple as that. Calling them is equally easy. just use their name. You just have to remember when using local variables and method names, the all must be different. Here is an example: class Class_Name def initialize @variable = 0 method_2 #Calls method_2 end def method_2 #method_2 print @variable end end Now when you call Class_Name using Class_Name.new, you get the same result, because we call method_2 RIGHT after defining the variable. Now, if the variable was a local variable it wouldnt work and you would get an error. If you are wondering why, go back and read about variables again, because I don't want to explain myself twice. Just never forget that variables can store text, numbers, even actor information or even an entire class. Now, you should know how a class structure works. You start with the class name, then the method (you have to use def to define it, don't forget!), then insert anything in the method, close it, add another if needed, close it if another exists, then close the class. Now, with all of this out of the way, you should know the following: What a class is and how to create it. What a method is and how to create one. What each variable type is and how to define a variable. A small list, it seems, but these are the building blocks of scripting. The first assignment will be coming up shortly after this, so be sure to go over your notes. Read Lesson 2 Section I

All right, now we are going to take a look at the structure of a script. By now, you are probably thinking 'Let's get on with the scripting already!'. Well, if you are thinking that, I have a word of advice: You cannot build a house if you don't know how to frame it. All that means is if you don't know the structure, you can't expect it to work very well. For classes, there is one thing we must answer before we even start writing the class, and that is what it will be used for. The reason: We need to know if there is a superclass. A superclass a class that this class will gain abilities from, if that makes sense. For example: If you were going to make a window, you would choose from the following list of superclasses: Window_Base, Window_Selectable, and Window_Command. Each one of these has their own superclass, and it all traces back to the emperor! Wait, wrong movie. It all traces back to the class 'Window'. In fact, here is a look at how it all works: Window -> Window_Base -> Window_Selectable -> Window_Command Basically: Window_Base has all of the abilities of Window. Window_Selectable has all of the abilities of Window and Window_Base. Window_Command has the abilities of all three. Now, why dont we just use Window_Command for everything? Well, even though it has the abilities of all the others, it would make it so each window is super-complicated. In fact, the only time I use Window_Command is if i need a menu where an option is disabled. Otherwise, i use Window_Selectable. That is an explaination of a superclass. It is a class that is a 'parent class' to another class. So Window_Base has the superclass of Window. Why is this important? Well, it is either that, or you can write out the code for each and every window separately... making each one about 200 lines rather than about.... 20. Now that we know what a superclass is, let's look at the structure of a class: class Class_Example def method_one end def method_two end end In the example above, we have identified a class by the word... well... 'class' (NOTE: This is your first keyword. you should keep track of these til you get a handle on them.). After that comes the name of the class, which starts with a capitol letter. If you notice, it doesn't start with Game, Window or Scene. A scene can be named anything, it is what is on the inside that counts. (beautiful...) Well, inside we have 'def method_one'. def is the keyword for defining a method. Everything inside of the method will trigger whenever the method is called, and it will be triggered in order. After this, we have end. end is needed every time you use something like class or method. There are many other things you will need to use end for, so you will see it alot. Basically, it ends the current process. Now, as a quick review: A class is a collection of methods that all work together to serve a purpose. A method is a code snippet that triggers when called. Now you know what a class is, what a superclass is, what a method is, and what end does. You also know the variable types. In the next section, we'll cover: How to use all of these together to make a simple window. Showing the power of superclasses. Show how to call methods. Read Section III

Greetings. marked has done a fine job as admin. He even fixed the site after I screwed up.. but that's in the past.

Ok, an update on the progress: I have only 13 maps to go, then i have to rig up the teleport events, which are cake. if I stay on task and work tomorrow all day, it should be done by friday. if not, then some time next week. But, this is getting closer, and even I will be testing. Trust me, it will be a real challenge.

Ok, for starters, I hate trying to keep track of everyone and so forth, so I'll make enrollment simple. You are a level one until you hand in the assignment, once looked over, corrected, and if it needs discussion or anything, talked over, I will bump you up in ranks. This will probably have an immediate effect within 3 days of being submitted. Now, the top says 'Enrollment'. Basically, in so many words, what I jsut said was it is open enrollment, and you can quit whenever. Just be sure to keep a record of all the stuff you learn in this class on your computer. I only have 40GB harddrive (an ancient laptop) so I can't keep track of all of your stuff along with my own. With that said, enjoy the lessons.

Ok, as it says in the topic description, this here will explain how I'll teach things, what the variables are, and how to do documentation. The way I do things is simple. I won't bore you with technical terms because you won't exactly use them all the time. Also, we'll progress through examples, rather than me explain what everything is in technical terms and how to use it. Also, I won't sit here and write up your scripts for you, but I will help with error correction and detection. Anyway, let's get this show on the road. I hate long tutorials so I'll keep it short. First, Documentation. Now, you are probably thinking 'why the world am I documenting everything?'. Well, I can tell you from personal experience, it pays off. I have gone back time and again to correct an error, or enhance a script only to spend 2 hours trying to understand my own structure. If you still don't think documentation is important, go ahead and skip this section, you'll only be setting yourself up for a fall later. With documentation, there are two types: -Commented Documentation -Implated Documentation. Granted, those arent the real terms, but what the heck, I'm loose with the rules. The first one, commented, means you use comment lines or comment blocks to describe what something does. To draw a single line, use a # sign right before the comment. To write a comment block, use =begin and =end. For example: =begin This is a comment block. It will appear green, and doesn't do anything to the code. =end #pops up the the first actor in the database. This is a comment line. print $game_actors[1] Above is an example of a comment block, comment line, and a comment used to describe a line. I just did the comment line and describing comment in the same thing. I'm lazy. The second type of documentation is 'implanted'. THis means the names that you give variables, classes, etc. will describe what it does. For example, we can assume the variable: @str refers to strength simply because 'STR' is the abbreviation for strength. It is important to give your variables meaningful names that are easy to remember. Last thing you want is something like this: @leon = @bung + @hole Although very humorous, it isnt exactly appropriate, and it has NO meaning whatsoever to whoever sees it, including you. Now, onto variable types: There are 5 different variable types, and this section will tell you each and give a very brief description of each: local_variable A variable usable only inside a method. I'll explain methods later. @instance_variable A variable usable throughout instance methods of a entire class. Each instance of a class has a copy of this variable and it is not shared among instances of a class. @@class_variable A variable usable throughout the entire class. This type of variable is shared among instances of a class. You must initialize this to a value before it is used. $global_variable A variable usable anywhere in the program. Constant_Variable A variable exclusive to a class/module that never changes. (Though, Ruby defeats the purpose, enabling you to change the constant during runtime.) As you can see, every variable type is lowercased with the exception of a constant variable. That there is an important rule, don't forget it. Also, dont forget that a local variable is exclusive to a method. Well, what is a method? Or a class? Well, hold on to your belly button, we are going to explain all of that in section II. Just keep this info fresh in your mind, and we'll continue onward into the scripting lesson. Credits to Trickster for correcting a couple of my errors. Read Section II

The more the merrier. With 125 maps to explore, you guys are sure to have fun. Just remember, the menu and most events are disabled, to keep the suspense built up. I do think, however, I'll leave in the weather variable, to see how you guys react.

thanks. I am about 17% done with this project overall, and hope it will be complete.

Nothing as of yet, mainly because of secrecy and the lack of the option for a demo. This game is pretty much an 'all or nothing' type game. No way to really compile a demo. As for characters, well... I am still working on them. Much more ground to cover, including the finding of sprites.

It isnt too late. I still have about a week (or possibly less) before it will be done.

The contest made me realize there is more to mapping than just graphics. When you go outside, there is more than just sight. There is sounds, things moving, noises, and even things that hurt when touched. :D

Here is a script that will allow you to power up your skills, and even allow passive skills. To call it, use $scene = Scene_Skill_Level.new Bon Appetit. #---------------------------------------------------------------------- # Skill Level System #---------------------------------------------------------------------- # Leon # 2006-09-16 # v1.5 #---------------------------------------------------------------------- =begin Features: 1. You can set skill level's and skill max's custom to each actor. 2. You can set skills to have a standard skill max and starting point. 3. Shows skills in detail. 4. Skill points per level can be customized. 5. You can change skill levels and skill max's through events. 6. You can have level and Skill prerequisites (sorry, only one each.) 7. Skill Power goes up per level. Added Feature: You can add status ailments, status curatives, and elements to skills. INSTRUCTIONS: 1. Place this script under all your others and above Main. 2. Set Beginning_Default to the level you want all skills to start at. 3. Set Max_Default to the max level of the average skill 4. Level_Req sets the a required level for skills. 5. Skill_Req sets required skills. 7. Set all instances of INCREASE_PER_LEVEL to the same number, (Use Ctrl + F to find all instances) 8. Set all instances of PASSIVE_SKILL_ID to the same number. (Use Ctrl + F to find all instances) 9. Use Ctrl + F and search for Leon_Edit for the final pieces to edit (only 2 other locales) 10. Set the additive element ailments, curatives and elements in their respective places. Use this to add to current skill levels: x = actor's number, y = skill id, z = amount. use $game_actors[x].skill_level[y] += z use this to add to current skill max's: x = actor's number, y = skill id, z = amount. use $game_actors[x].skill_max[y] += z To subtract from the totals, change the '+' to '-' =end module Skill_Level #-------------------------------------------------------------------- # Skill_Default_Beginning_Level #-------------------------------------------------------------------- Beginning_Default = 0 #-------------------------------------------------------------------- # Skill default max level #-------------------------------------------------------------------- Max_Default = 5 #-------------------------------------------------------------------- # Actor Level Requirements # skill_id => actor.level #-------------------------------------------------------------------- Level_Req = { 2 => 2 } #-------------------------------------------------------------------- # Skill Level Requirements # skill_id => [required skill_id, required skill_level, skill name of required skill] #-------------------------------------------------------------------- Skill_Req = { 57 => [1, 2, "Heal"] } #-------------------------------------------------------------------- # Skill Infliction Status Additions # skill_id => [skill_level, plus_state_set id] #-------------------------------------------------------------------- Skill_Add = { 57 => [2, 3] } #-------------------------------------------------------------------- # Skill Cure Status Removals # skill_id => [skill_level, minus_state_set id] #-------------------------------------------------------------------- Skill_Minus = { 1 => [2, 2] } #-------------------------------------------------------------------- # Skill Element Addition # skill_id => [skill_level, element_set] #-------------------------------------------------------------------- Skill_Element = { 1 => [2, 4] } #-------------------------------------------------------------------- # HP Max Plus skills # skill.id => %change per level #-------------------------------------------------------------------- Skill_HP = { 1 => 5, 81 => 25 } end #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Game_Battler #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class Game_Battler #-------------------------------------------------------------------- # Set's Percentage Increase # Set each INCREASE_PER_LEVEL in the script to the same number #-------------------------------------------------------------------- INCREASE_PER_LEVEL = 10 #-------------------------------------------------------------------- # Alias Listings #-------------------------------------------------------------------- alias leon_gb_skilleffect skill_effect #-------------------------------------------------------------------- # Skill Effect #-------------------------------------------------------------------- def skill_effect(user, skill) self.critical = false if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1) return false end effective = false effective |= skill.common_event_id > 0 hit = skill.hit if skill.atk_f > 0 hit *= user.hit / 100 end hit_result = (rand(100) < hit) effective |= hit < 100 if hit_result == true if user.is_a?(Game_Actor) power = (skill.power + (INCREASE_PER_LEVEL * user.skill_level[skill.id][0] * 0.01 * skill.power)) + user.atk * skill.atk_f / 100 else power = skill.power + user.atk * skill.atk_f / 100 end power = power.round if power > 0 power -= self.pdef * skill.pdef_f / 200 power -= self.mdef * skill.mdef_f / 200 power = [power, 0].max end rate = 20 rate += (user.str * skill.str_f / 100) rate += (user.dex * skill.dex_f / 100) rate += (user.agi * skill.agi_f / 100) rate += (user.int * skill.int_f / 100) self.damage = power * rate / 20 self.damage *= elements_correct(skill.element_set) self.damage /= 100 if self.damage > 0 if self.guarding? self.damage /= 2 end end if skill.variance > 0 and self.damage.abs > 0 amp = [self.damage.abs * skill.variance / 100, 1].max self.damage += rand(amp+1) + rand(amp+1) - amp end eva = 8 * self.agi / user.dex + self.eva hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100 hit = self.cant_evade? ? 100 : hit hit_result = (rand(100) < hit) effective |= hit < 100 end if hit_result == true if skill.power != 0 and skill.atk_f > 0 remove_states_shock effective = true end last_hp = self.hp self.hp -= self.damage effective |= self.hp != last_hp @state_changed = false effective |= states_plus(skill.plus_state_set) effective |= states_minus(skill.minus_state_set) if skill.power == 0 self.damage = "" unless @state_changed self.damage = "Miss" end end else self.damage = "Miss" end unless $game_temp.in_battle self.damage = nil end return effective end end #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Game_Actor #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class Game_Actor < Game_Battler #-------------------------------------------------------------------- # Constant Variables # Leon_Edit # Set the BASE_MAXHP, BASE_MAXSP, BASE_STR, etc... # to the skill id's of those passive skills. Only 1 id each. # Set SKILL_POINTS equal to the number of skill points per level. # Set SKILL_POINTS equal to 0 if none are to be earned. #-------------------------------------------------------------------- INCREASE_PER_LEVEL = 10 BASE_MAXSP = 2 #SP BASE_STR = 2 #STR BASE_DEX = 2 #DEX BASE_AGI = 2 #AGI BASE_INT = 2 #INT SKILL_POINTS = 1 #-------------------------------------------------------------------- # Attribute Listings #-------------------------------------------------------------------- attr_accessor :skill_level attr_accessor :skill_max attr_accessor :skill_points attr_accessor :hp_percent #-------------------------------------------------------------------- # Alias Listings #-------------------------------------------------------------------- alias leon_ga_skill_level_setup setup alias leon_ga_skill_level_skill_learn? skill_learn? alias leon_ga_skill_level_exp exp alias leon_ga_skill_level_basehp base_maxhp alias leon_ga_skill_level_basesp base_maxsp alias leon_ga_skill_level_basestr base_str alias leon_ga_skill_level_basedex base_dex alias leon_ga_skill_level_baseagi base_agi alias leon_ga_skill_level_baseint base_int #-------------------------------------------------------------------- # Setup #-------------------------------------------------------------------- def setup(actor_id) #-------------------------------------------------------------------- # Leon_Edit # Put in unique beginning levels here. # skill_id => starting_level #-------------------------------------------------------------------- @skill_level = { 1 => 2, 57 => 0 } #-------------------------------------------------------------------- # Leon_Edit # Put unique ending levels here. # skill_id => skill_end #-------------------------------------------------------------------- @skill_max = { 1 => 3, 57 => 7 } @skill_points = 0 @hp_percent = 0 leon_ga_skill_level_setup(actor_id) end def base_maxhp reqs = Skill_Level n = leon_ga_skill_level_basehp if skills.include?(reqs::Skill_HP) print ("True") end if reqs::Skill_HP.has_key?(skills) n += (reqs::Skill_HP[skills] * 0.01 * n) end return n end def base_maxsp n = leon_ga_skill_level_basesp if skills.include?(BASE_MAXSP) n += (INCREASE_PER_LEVEL * 0.01 * n * skill_level[BASE_MAXSP]) end return n end def base_str n = leon_ga_skill_level_basestr if skills.include?(BASE_STR) n += (INCREASE_PER_LEVEL * 0.01 * n * skill_level[BASE_STR]) end return n end def base_dex n = leon_ga_skill_level_basedex if skills.include?(BASE_DEX) n += (INCREASE_PER_LEVEL * 0.01 * n * skill_level[BASE_DEX]) end return n end def base_int n = leon_ga_skill_level_baseint if skills.include?(BASE_INT) n += (INCREASE_PER_LEVEL * 0.01 * n * skill_level[BASE_INT]) end return n end def base_agi n = leon_ga_skill_level_baseagi if skills.include?(BASE_AGI) n += (INCREASE_PER_LEVEL * 0.01 * n * skill_level[BASE_AGI]) end return n end def skill_learn?(skill_id) reqs = Skill_Level unless @skill_level.include?(skill_id) @skill_level[skill_id] = reqs::Beginning_Default end unless @skill_max.include?(skill_id) @skill_max[skill_id] = reqs::Max_Default end leon_ga_skill_level_skill_learn?(skill_id) end def skill_can_learn?(skill_id) reqs = Skill_Level if reqs::Level_Req.has_key?(skill_id) unless level >= reqs::Level_Req[skill_id] return false end end if reqs::Skill_Req.has_key?(skill_id) unless level >= reqs::Skill_Req[skill_id][0] return false end end return true end def skill_can_use?(skill_id) reqs = Skill_Level if reqs::Skill_Add.has_key?(skill_id) if skill_level[skill_id] >= reqs::Skill_Add[skill_id][0] $data_skills[skill_id].plus_state_set.push(reqs::Skill_Add[skill_id][1]) end end if reqs::Skill_Minus.has_key?(skill_id) if skill_level[skill_id] >= reqs::Skill_Minus[skill_id][0] $data_skills[skill_id].minus_state_set.push(reqs::Skill_Minus[skill_id][1]) end end if reqs::Skill_Element.has_key?(skill_id) if skill_level[skill_id] >= reqs::Skill_Element[skill_id][0] unless $data_skills[skill_id].element_set.include?(reqs::Skill_Element[skill_id][1]) $data_skills[skill_id].element_set.push(reqs::Skill_Element[skill_id][1]) end end end return false unless leon_skill_level_levelcheck(skill_id) return false unless leon_skill_level_skillcheck(skill_id) if not skill_learn?(skill_id) return false end if skill_level[skill_id] == 0 return false end return super end def leon_skill_level_levelcheck(skill_id) reqs = Skill_Level if reqs::Level_Req.has_key?(skill_id) unless level >= reqs::Level_Req[skill_id] return false end end return true end def leon_skill_level_skillcheck(skill_id) reqs = Skill_Level if reqs::Skill_Req.has_key?(skill_id) skill_number = reqs::Skill_Req[skill_id][0] unless skill_level[skill_number] >= reqs::Skill_Req[skill_id][1] return false end end return true end def exp=(exp) @exp = [[exp, 9999999].min, 0].max while @exp >= @exp_list[@level+1] and @exp_list[@level+1] > 0 @level += 1 @skill_points += SKILL_POINTS for j in $data_classes[@class_id].learnings if j.level == @level learn_skill(j.skill_id) end end end while @exp < @exp_list[@level] @level -= 1 end @hp = [@hp, self.maxhp].min @sp = [@sp, self.maxsp].min end end #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Window_Skill #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ class Window_Skill #-------------------------------------------------------------------- # Constant Listings #-------------------------------------------------------------------- PASSIVE_SKILL_ID = 19 #-------------------------------------------------------------------- # Alias Listings #-------------------------------------------------------------------- alias leon_ws_skill_level_refresh refresh def refresh if self.contents != nil self.contents.dispose self.contents = nil end @data = [] for i in 0...@actor.skills.size skill = $data_skills[@actor.skills[i]] if skill != nil if @actor.skill_level[skill.id] > 0 unless skill.element_set.include?(PASSIVE_SKILL_ID) @data.push(skill) end end end end @item_max = @data.size if @item_max > 0 self.contents = Bitmap.new(width - 32, row_max * 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize for i in 0...@item_max draw_item(i) end end end end #---------------------------------------------------------------------- # Window_Skillinfo Info Window #---------------------------------------------------------------------- class Window_Skillinfo < Window_Base def initialize super(0, 0, 640, 64) self.contents = Bitmap.new(width - 32, height - 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize end def update(help_text) self.contents.clear self.contents.draw_text(0, 0, 600, 32, help_text) end end #---------------------------------------------------------------------- # Window_Skillhero Hero Window #---------------------------------------------------------------------- class Window_Skillhero < Window_Base def initialize(actor) super(0, 64, 180, 128) self.contents = Bitmap.new(width - 32, height - 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize @actor = actor refresh end def refresh self.contents.clear draw_actor_name(@actor, 50, 0) draw_actor_class(@actor, 50, 32) self.contents.draw_text(100, 64, 40, 32, @actor.skill_points.to_s) self.contents.font.color = system_color self.contents.draw_text(0, 0, 45, 32, "Name:") self.contents.draw_text(0, 32, 45, 32, "Class:") self.contents.draw_text(0, 64, 95, 32, "Skill Points:") end end #---------------------------------------------------------------------- # Window_Skillpre Prerequisite Window #---------------------------------------------------------------------- class Window_Skillpre < Window_Base def initialize(skill) super(0, 288, 180, 192) self.contents = Bitmap.new(width - 32, height - 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize end def update(skill) self.contents.clear self.contents.font.color = system_color self.contents.draw_text(0, 0, 140, 32, "Prerequisites:") self.contents.draw_text(4, 32, 140, 32, "Level:") self.contents.draw_text(4, 64, 45, 32, "Skill:") self.contents.font.color = normal_color reqs = Skill_Level if reqs::Level_Req.has_key?(skill.id) self.contents.draw_text(55, 32, 140, 32, reqs::Level_Req[skill.id].to_s) else self.contents.draw_text(55, 32, 140, 32, "None") end if reqs::Skill_Req.has_key?(skill.id) self.contents.draw_text(8, 96, 140, 32, reqs::Skill_Req[skill.id][2].to_s) self.contents.draw_text(8, 128, 140, 32, "Lvl: " + reqs::Skill_Req[skill.id][1].to_s) else self.contents.draw_text(8, 96, 140, 32, "None") end end def update1 self.contents.clear self.contents.font.color = system_color self.contents.draw_text(0, 0, 140, 32, "Prerequisites:") self.contents.draw_text(4, 32, 140, 32, "Level:") self.contents.draw_text(4, 64, 45, 32, "Skill:") end end #---------------------------------------------------------------------- # Window_Skilllist List Window #---------------------------------------------------------------------- class Window_Skilllist < Window_Selectable #-------------------------------------------------------------------- # Set Passive Skill ID here. #-------------------------------------------------------------------- PASSIVE_SKILL_ID = 19 def initialize(actor) super(180, 64, 460, 416) @column_max = 2 self.contents = Bitmap.new(width - 32, height - 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize @actor = actor self.active = false self.index = -1 end def skill if @data !=nil return @data[@index] end end def refresh if self.contents != nil self.contents.dispose self.contents = nil end @data = [] for i in 0...@actor.skills.size skill = $data_skills[@actor.skills[i]] if skill != nil unless skill.element_set.include?(PASSIVE_SKILL_ID) @data.push(skill) end end end @item_max = @data.size if @item_max > 0 self.contents = Bitmap.new(width - 32, row_max * 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize for i in 0...@item_max draw_item(i) end end end def draw_item(index) skill = @data[index] if @actor.skill_can_learn?(skill.id) == true self.contents.font.color = normal_color else self.contents.font.color = disabled_color end unless skill.element_set.include?(PASSIVE_SKILL_ID) x = 4 + index % 2 * (195 + 32) y = index / 2 * 32 rect = Rect.new(x, y, self.width / @column_max - 32, 32) self.contents.fill_rect(rect, Color.new(0, 0, 0, 0)) bitmap = RPG::Cache.icon(skill.icon_name) opacity = self.contents.font.color == normal_color ? 255 : 128 self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity) self.contents.draw_text(x + 28, y, 134, 32, skill.name, 0) if @actor.skill_level[skill.id] == @actor.skill_max[skill.id] self.contents.font.color = Color.new(40, 250, 40, 255) self.contents.draw_text(x +155, y, 100, 32, "Max") else self.contents.font.color = Color.new(250, 250, 13, 255) self.contents.draw_text(x + 159, y, 100, 32, (@actor.skill_level[skill.id].to_s) + "/" + (@actor.skill_max[skill.id].to_s)) end end end def refresh1 if self.contents != nil self.contents.dispose self.contents = nil end @data = [] for i in 0...@actor.skills.size skill = $data_skills[@actor.skills[i]] if skill != nil if skill.element_set.include?(PASSIVE_SKILL_ID) @data.push(skill) end end end @item_max = @data.size if @item_max > 0 self.contents = Bitmap.new(width - 32, row_max * 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize for i in 0...@item_max draw_item1(i) end end end def draw_item1(index) skill = @data[index] if @actor.skill_can_learn?(skill.id) == true self.contents.font.color = normal_color else self.contents.font.color = disabled_color end if skill.element_set.include?(PASSIVE_SKILL_ID) x = 4 + index % 2 * (195 + 32) y = index / 2 * 32 rect = Rect.new(x, y, self.width / @column_max - 32, 32) self.contents.fill_rect(rect, Color.new(0, 0, 0, 0)) bitmap = RPG::Cache.icon(skill.icon_name) opacity = self.contents.font.color == normal_color ? 255 : 128 self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity) self.contents.draw_text(x + 28, y, 134, 32, skill.name, 0) if @actor.skill_level[skill.id] == @actor.skill_max[skill.id] self.contents.font.color = Color.new(40, 250, 40, 255) self.contents.draw_text(x +155, y, 100, 32, "Max") else self.contents.font.color = Color.new(250, 250, 13, 255) self.contents.draw_text(x + 159, y, 100, 32, (@actor.skill_level[skill.id].to_s) + "/" + (@actor.skill_max[skill.id].to_s)) end end end end #---------------------------------------------------------------------- # Window_Skilldesc #---------------------------------------------------------------------- class Window_Skilldesc < Window_Base #-------------------------------------------------------------------- # Set Passive skill ID to the same as above. # Set INCREASE_PER_LEVEL the same as the ones above #-------------------------------------------------------------------- PASSIVE_SKILL_ID = 19 INCREASE_PER_LEVEL = 10 def initialize(actor, skill) super(45, 40, 550, 400) self.contents = Bitmap.new(width - 32, height - 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize @actor = actor self.visible = false self.z = 1000 end def refresh(skill) self.contents.clear @actor.skill_can_use?(skill.id) bitmap = RPG::Cache.icon(skill.icon_name) self.contents.font.color = system_color #Draws 'Elements:' self.contents.draw_text(205, 96, 120, 32, "Elements:") #Draws the word for SP self.contents.draw_text(410, 0, 80, 32, $data_system.words.sp + ":") #Draws 'Skill Level:' self.contents.draw_text(200, 0, 120, 32, "Skill Level:") #Draws 'Cures:' self.contents.draw_text(0, 96, 120, 32, "Cures:") #Draws 'Inflicts:' self.contents.draw_text(0, 228, 120, 32, "Inflicts:") #Draws 'Next Level's Range:' self.contents.draw_text(355, 96, 165, 32, "Next Level's Range:", 1) #Attack Influence self.contents.font.size = 18 #Draws 'Increase per Level:' self.contents.draw_text(145, 324, 150, 32, "Increase per Level:") #Draws 'Range' self.contents.draw_text(345, 304, 165, 32, "Range:") #Draws Attack Type self.contents.draw_text(345, 324, 120, 32, "Skill Type:") #Draws 'Attack' influence self.contents.draw_text(145, 228, 120, 32, "Atk Influence:") #Draws 'PDEF' influence self.contents.draw_text(145, 247, 120, 32, "P-DEF Influence:") #Draws 'MDEF' influence self.contents.draw_text(145, 266, 120, 32, "M-DEF Influence:") #Draws 'Accuracy' self.contents.draw_text(145, 285, 120, 32, "Accuracy:") self.contents.font.size = $defaultfontsize self.contents.font.color = normal_color #Sets Icon Opacity opacity = self.contents.font.color == normal_color ? 255 : 128 #Draws Icon self.contents.blt(0, 4, bitmap, Rect.new(0, 0, 24, 24), opacity) #Draws Skill Name self.contents.draw_text(28, 0, 184, 32, skill.name, 0) #Draws SP cost self.contents.draw_text(450, 0, 90, 32, skill.sp_cost.to_s) #Draws Skill Level Number self.contents.font.color = Color.new(250, 250, 13, 255) self.contents.draw_text(290, 0, 50, 32, (@actor.skill_level[skill.id]).to_s + "/" + (@actor.skill_max[skill.id]).to_s) self.contents.font.color = normal_color #Draws Skill Description self.contents.draw_text(4, 48, 330, 32, skill.description) #Draws Atk Influence self.contents.font.size = 18 #Draws Skill Type if skill.atk_f > 0 self.contents.draw_text(420, 324, 80, 32, "Physical") else self.contents.draw_text(420, 324, 80, 32, "Magical") end self.contents.draw_text(235, 228, 30, 32, skill.atk_f.to_s, 2) self.contents.draw_text(254, 247, 30, 32, skill.pdef_f.to_s, 2) self.contents.draw_text(257, 266, 30, 32, skill.mdef_f.to_s, 2) self.contents.draw_text(210, 285, 30, 32, skill.hit.to_s, 2) #Draws % increase self.contents.draw_text(277, 324, 50, 32, "+" + INCREASE_PER_LEVEL.to_s + "%") #Draws Range case skill.scope when 0 self.contents.draw_text(399, 304, 165, 32, "None") when 1 self.contents.draw_text(399, 304, 165, 32, "One Enemy") when 2 self.contents.draw_text(399, 304, 165, 32, "All Enemies") when 3 self.contents.draw_text(399, 304, 165, 32, "One Ally") when 4 self.contents.draw_text(399, 304, 165, 32, "All Allies") when 5 self.contents.draw_text(399, 304, 165, 32, "Ko'ed Allies") when 6 self.contents.draw_text(399, 304, 165, 32, "User") end self.contents.font.size = $defaultfontsize #Formulas for Next Level Range #Formula for when skills level up power1 = (((INCREASE_PER_LEVEL * 0.01 * @actor.skill_level[skill.id])* skill.power) + skill.power) power2 = (((INCREASE_PER_LEVEL * 0.01 * (@actor.skill_level[skill.id] +1))* skill.power) + skill.power) #Draws Range next_level_range = (power2 * (skill.variance * -0.01) + power2).to_s + " - " + (power2 * (skill.variance * 0.01) + power2).to_s next_level_range2 = ((power2 * (skill.variance * -0.01) + power2) * -1).to_s + " - " + ((power2 * (skill.variance * 0.01) + power2) * -1).to_s #Draws skill elements. elements = [] skill.element_set.each do |i| unless [PASSIVE_SKILL_ID].include?(i) elements << $data_system.elements[i] end end for i in 0...elements.size self.contents.font.size = 16 self.contents.draw_text(165 + ((i % 2) * 94), 120 + (i / 2 * 12), 120, 32, elements[i]) end #Draws negated effects minus_status_data = [] for i in 1...$data_states.size if skill.minus_state_set.include?(i) minus_status_data.push($data_states[i].name) end end for i in 0...minus_status_data.size self.contents.font.size = 16 self.contents.draw_text(0 + ((i % 2) * 85), 120 + (i / 2 * 12), 120, 32, minus_status_data[i]) end #Draws added statuses plus_status_data = [] for i in 1...$data_states.size if skill.plus_state_set.include?(i) plus_status_data.push($data_states[i].name) end end for i in 0...plus_status_data.size self.contents.font.size = 16 self.contents.draw_text(0 + ((i % 2) * 85), 252 + (i / 2 * 12), 120, 32, plus_status_data[i]) end #If skill is a heal skill... if skill.power < 0 self.contents.font.size = $defaultfontsize self.contents.font.color = system_color self.contents.draw_text(355, 32, 165, 32, "Heal Range:", 1) self.contents.draw_text(355, 160, 170, 32, "Level's Healing Avg:") self.contents.draw_text(355, 228, 165, 32, "Next Level's Avg:", 1) self.contents.font.color = Color.new(64, 245, 128, 255) #If skill_level is higher than 0... if @actor.skill_level[skill.id] > 0 #Draw level's Heal Range self.contents.draw_text(355, 64, 165, 32, (((skill.variance * -0.01) * power1 + power1) * -1).to_s + " - " + (((skill.variance * 0.01) * power1 + power1) * -1).to_s, 1) else #Draw level 0's heal range self.contents.draw_text(355, 64, 165, 32, 0.to_s + " - " + 0.to_s, 1) end #If skill_level is higher than 0... if @actor.skill_level[skill.id] > 0 #Draw's Level's current average power self.contents.draw_text(355, 192, 165, 32, (power1 * -1).to_s, 1) else #Draws Level's Healing Average Power self.contents.draw_text(355, 192, 165, 32, 0.to_s, 1) end #Draws Next level's Healing Average if @actor.skill_level[skill.id] == @actor.skill_max[skill.id] self.contents.draw_text(355, 260, 165, 32, "----------", 1) else self.contents.draw_text(355, 260, 165, 32, (power2 * -1).to_s, 1) end #Draws Next level's range if @actor.skill_level[skill.id] == @actor.skill_max[skill.id] self.contents.draw_text(355, 128, 165, 32, "----------", 1) else self.contents.draw_text(355, 128, 165, 32, next_level_range2, 1) end self.contents.font.color = normal_color else self.contents.font.size = $defaultfontsize self.contents.font.color = system_color self.contents.draw_text(355, 32, 165, 32, "Power Range:", 1) self.contents.draw_text(355, 160, 165, 32, "Level's Power Avg:", 1) self.contents.draw_text(355, 228, 165, 32, "Next Level's Avg:", 1) self.contents.font.color = Color.new(210, 37, 2, 255) #If skill_level is higher than 0... if @actor.skill_level[skill.id] > 0 #Draw Damage Range self.contents.draw_text(355, 64, 165, 32, ((skill.variance * -0.01) * power1 + power1).to_s + " - " + ((skill.variance * 0.01) * power1 + power1).to_s, 1) else #Draw level 0's range self.contents.draw_text(355, 64, 165, 32, 0.to_s + " - " + 0.to_s, 1) end #If skill_level is higher than 0... if @actor.skill_level[skill.id] > 0 #Draw Damage Average self.contents.draw_text(355, 192, 165, 32, power1.to_s, 1) else #Draw level 0's Avg self.contents.draw_text(355, 192, 165, 32, 0.to_s, 1) end #Draw's Next Level's Avg. if @actor.skill_level[skill.id] == @actor.skill_max[skill.id] self.contents.draw_text(355, 260, 165, 32, "----------", 1) else self.contents.draw_text(355, 260, 165, 32, power2.to_s, 1) end #Draw's Next Level's Range if @actor.skill_level[skill.id] == @actor.skill_max[skill.id] self.contents.draw_text(355, 128, 165, 32, "----------", 1) else self.contents.draw_text(355, 128, 165, 32, next_level_range, 1) end self.contents.font.color = normal_color end end end #=================================== # Window_Confirm #=================================== class Window_Skillconfirm < Window_Selectable def initialize super(256, 192, 128, 96) self.contents = Bitmap.new(width - 32, height - 32) self.contents.font.name = $defaultfonttype self.contents.font.size = $defaultfontsize self.visible = false self.z = -1000 self.index = -1 self.active = false end def refresh self.contents.clear @data = [self.contents.draw_text(0, 0, 96, 32, "Yes", 1), self.contents.draw_text(0, 32, 96, 32, "No", 1)] @item_max = @data.size end end #+++++++++++++++++++++++++++++++++++ # Scene_Skill_Level #+++++++++++++++++++++++++++++++++++ class Scene_Skill_Level def initialize(actor_index = 0, skilltype_index = 0) @actor_index = actor_index @skilltype_index = skilltype_index end def main @actor = $game_party.actors[@actor_index] @skillinfo_window = Window_Skillinfo.new @skillhero_window = Window_Skillhero.new(@actor) @skilllist_window = Window_Skilllist.new(@actor) @skillpre_window = Window_Skillpre.new(@skilllist_window.skill) @skilldesc_window = Window_Skilldesc.new(@actor, @skilllist_window.skill) @confirm_window = Window_Skillconfirm.new @skill = @skilllist_window.skill c1 = "Active" c2 = "Passive" @skilltype_window = Window_Command.new(180, [c1, c2]) @skilltype_window.y = 192 @skilltype_window.index = @skilltype_index Graphics.transition loop do Graphics.update Input.update update if $scene != self break end end Graphics.freeze @skillinfo_window.dispose @skillhero_window.dispose @skillpre_window.dispose @skilllist_window.dispose @skilltype_window.dispose @skilldesc_window.dispose @confirm_window.dispose end def update @skillhero_window.update @skilltype_window.update @skilldesc_window.update @skillpre_window.update1 if @skilltype_window.active update_skilltype return end if @skilllist_window.active update_skilllist return end if @skilldesc_window.visible update_skilldesc return end if @confirm_window.active update_confirm return end if Input.trigger?(Input::L) $game_system.se_play($data_system.cursor_se) @actor_index += $game_party.actors.size - 1 @actor_index %= $game_party.actors.size $scene = Scene_Skill_level.new end if Input.trigger?(Input::R) $game_system.se_play($data_system.cursor_se) @actor_index += 1 @actor_index %= $game_party.actors.size $scene = Scene_Skill_level.new end end def update_skilltype if @skilltype_window.index == 0 @skillinfo_window.update("Shows active skills.") @skilllist_window.refresh if Input.trigger?(Input::C) @skilltype_window.active = false @skilllist_window.active = true @skilllist_window.index = 0 end else @skillinfo_window.update("Shows passive skills.") @skilllist_window.refresh1 if Input.trigger?(Input::C) @skilltype_window.active = false @skilllist_window.active = true @skilllist_window.index = 0 end end if Input.trigger?(Input::L) $game_system.se_play($data_system.cursor_se) @actor_index += $game_party.actors.size - 1 @actor_index %= $game_party.actors.size $scene = Scene_Skill_level.new(@actor_index) end if Input.trigger?(Input::R) $game_system.se_play($data_system.cursor_se) @actor_index += 1 @actor_index %= $game_party.actors.size $scene = Scene_Skill_level.new(@actor_index) end if Input.trigger?(Input::B) $scene = Scene_Map.new end end def update_skilllist @skillpre_window.update(@skilllist_window.skill) @skilllist_window.update @confirm_window.z = -1000 @skillinfo_window.update("Press 'A' for Skill Description") if Input.trigger?(Input::B) @skilllist_window.index = -1 @skilllist_window.active = false @skilltype_window.active = true return end if Input.trigger?(Input::A) if @skilllist_window.skill != nil @skilldesc_window.refresh(@skilllist_window.skill) @skilllist_window.active = false @skilldesc_window.visible = true else $game_system.se_play($data_system.buzzer_se) end end if Input.trigger?(Input::L) $game_system.se_play($data_system.cursor_se) @actor_index += $game_party.actors.size - 1 @actor_index %= $game_party.actors.size $scene = Scene_Skill_level.new(@actor_index) end if Input.trigger?(Input::R) $game_system.se_play($data_system.cursor_se) @actor_index += 1 @actor_index %= $game_party.actors.size $scene = Scene_Skill_level.new(@actor_index) end if Input.trigger?(Input::C) skill = @skilllist_window.skill if skill != nil if @actor.skill_can_learn?(skill.id) == true if @actor.skill_level[@skilllist_window.skill.id] < @actor.skill_max[@skilllist_window.skill.id] if @actor.skill_points > 0 @confirm_window.refresh @skilllist_window.active = false @confirm_window.active = true @confirm_window.visible = true @confirm_window.index = 0 else $game_system.se_play($data_system.buzzer_se) end else $game_system.se_play($data_system.buzzer_se) end else $game_system.se_play($data_system.buzzer_se) end end end end def update_skilldesc if @skilldesc_window.visible == true @skilllist_window.active = false if Input.trigger?(Input::B) @skilldesc_window.visible = false @skilllist_window.active = true end end end def update_confirm @skillpre_window.update(@skilllist_window.skill) @confirm_window.z = 1000 @confirm_window.update @skillinfo_window.update("Are you sure?") if Input.trigger?(Input::B) @confirm_window.active = false @confirm_window.visible = false @skilllist_window.active = true end if Input.trigger?(Input::C) if @skilltype_window.index == 0 case @confirm_window.index when 0 @actor.skill_level[@skilllist_window.skill.id] += 1 @actor.skill_points -= 1 @skillhero_window.refresh @skilllist_window.refresh @confirm_window.visible = false @skilllist_window.active = true @confirm_window.index = -1 return when 1 @confirm_window.visible = false @skilllist_window.active = true @confirm_window.index = -1 end else case @confirm_window.index when 0 @actor.skill_level[@skilllist_window.skill.id] += 1 @actor.skill_points -= 1 @skillhero_window.refresh @skilllist_window.refresh1 @confirm_window.visible = false @skilllist_window.active = true @confirm_window.index = -1 return when 1 @confirm_window.visible = false @skilllist_window.active = true @confirm_window.index = -1 end end end end end

Ok, so this script basically makes it so some floors can heal or damage the player's actors as you please. This actually makes use of Terrain Tags, too. Anyway, the instructions are in the script: #=================================== # Damaging and Healing Floors #---------------------------------------------------------------------- # # Features: # -Heals/Damages the actors if they step on certain tiles. # -Customizable amount of heal/damage. # -Can be based on either percentage or a fixed rate. # # Instructions: # -Place this script above Main, but below all other default scripts. # -Change the damage and heal tags to different numbers. By default # the are 1 for damage, 2 for heal. # -On your tilesets, go into the 'terrain' tag, and set all damage floor's # terrain number equal to the one set in the script for damage, and # do the same for any healing floors. # #=================================== #=================================== # Module #=================================== module Terrain_Tag_Setup #-------------------------------------------------------------------- # Percentage = # When true, takes away a percentage rather than a fixed amount. #-------------------------------------------------------------------- Percentage = true #-------------------------------------------------------------------- # Damage_Amount = # How much is taken away from each step. If Percentange = true # It will remove that percent. #-------------------------------------------------------------------- Damage_Amount = 10 #-------------------------------------------------------------------- # Heal_Amount = # How much is taken away from each step. If Percentange = true # It will remove that percent. #-------------------------------------------------------------------- Heal_Amount = 10 #-------------------------------------------------------------------- # Kill = # if true, damage floors can kill players. #-------------------------------------------------------------------- Kill = false #-------------------------------------------------------------------- # Damage_Tag = # The tag number that damages the player. #-------------------------------------------------------------------- Damage_Tag = 1 #-------------------------------------------------------------------- # Heal_Tag = # The tag number that heals the player. #-------------------------------------------------------------------- Heal_Tag = 2 end #=================================== # * Scene_Map #=================================== class Scene_Map alias leon_gamecharacter_moving_tt update def update leon_gamecharacter_moving_tt tts = Terrain_Tag_Setup if $game_map.terrain_tag($game_player.x, $game_player.y) == tts::Damage_Tag if $moved == true @counter = 0 $game_screen.start_flash(Color.new(200, 0, 0, 190), 15) Audio.se_play("Audio/SE/117-Fire01", 80, 130) for actor in $game_party.actors if (actor.hp - tts::Damage_Amount) < 1 actor.hp = 1 $moved = false else amt = tts::Damage_Amount if tts::Percentage == true amt = amt * 0.01 * actor.maxhp amt = amt.round end actor.hp -= amt if tts::Kill == false and actor.hp == 0 actor.hp = 1 else if actor.hp == 0 @counter += 1 end end if @counter == $game_party.actors.size $scene = Scene_Gameover.new end end end $moved = false end end if $game_map.terrain_tag($game_player.x, $game_player.y) == tts::Heal_Tag if $moved == true $game_screen.start_flash(Color.new(0, 200, 200, 190), 15) Audio.se_play("Audio/SE/105-Heal01", 80, 130) for actor in $game_party.actors amt = tts::Heal_Amount if tts::Percentage == true amt = amt * 0.01 * actor.maxhp amt = amt.round end actor.hp += amt end $moved = false end end end end #=================================== # * Game_Player #=================================== class Game_Player < Game_Character alias leon_gameactor_update_tt update def update unless moving? or $game_system.map_interpreter.running? or @move_route_forcing or $game_temp.message_window_showing case Input.dir4 when 2 $moved = true when 4 $moved = true when 6 $moved = true when 8 $moved = true end end leon_gameactor_update_tt end end

Gracias. Beats the hell out of the boring ones.

My mapping skills have increased substancially. Check Dark Tidings to see an update on my mapping skills. As stated before, this was one of my very first projects, and I didn't even do 1/2 the mapping. I had a friend do it (another novice at the time.)

Congrats, Marked, and everyone else here.

Yeah? What bugged ya? I'm interested in knowing.

Ok, I guess you can call this a fix for RmXP, if you want. With this script, you can use a switch to toggle on and off if the background music plays through the battle. It is really good for those 'dramatic' scenes like in Final Fantasy X. Basically, you turn on the switch for the battle, then turn it off after the battle. Simple, no? Anyway, you can even customize which switch is used for the script. here it is (instructions in the script, please read them.) #=================================== # Leon's battle BGM Fix #---------------------------------------------------------------------- # Feature: # You can turn off the battle music for battles, and let the # bgm play through. It will only be interupted by the music # effect of battle, then the music fades back in. # # Instructions: # Place after Scene_Debug, but before Main # set SWITCH_TO_BYPASS equal to the switch that needs # to be on for this to work. So, if SWITCH_TO_BYPASS equalled 1, # and switch 1 is on, the BGM plays through battle. When switch # 1 is off, it will turn on the battle background music. #=================================== class Scene_Map alias leon_bgmfix_scenemap_callbattle call_battle SWITCH_TO_BYPASS = 8 def call_battle $game_temp.battle_calling = false $game_temp.menu_calling = false $game_temp.menu_beep = false $game_player.make_encounter_count $game_temp.map_bgm = $game_system.playing_bgm unless $game_switches[SWITCH_TO_BYPASS] == true $game_system.bgm_stop $game_system.se_play($data_system.battle_start_se) $game_system.bgm_play($game_system.battle_bgm) end $game_player.straighten $scene = Scene_Battle.new end end

Tutorial is up, look under the tutorial section, and it will be there.