After testing my theory, it was almost right... almost.
Instead of calling the method for showing the images in the 'start_actor_command_selection' method, you should call it in the 'next_command' and 'prior_command'. This is to simplify the required modifications later on.
So, when you create a sprite, you need to assign a bitmap to it.
You created a sprite in the right way. However, make sure to use unique names for your variables, because if you use something like you just used, it might happen that you overwrite some previously created variable with the same name. @sprite1 is not really unique. Use something what actually describes what the thing is, like @battle_bust or something similar.
Now, if you want to assign an image directly to a sprite, you will need to assign a bitmap to the sprite and assign an image for the bitmap.
Use the cache for assigning the image for the bitmap. It is recommended to use the cache for images which appear a lot of times in your game. The battle busts will appear a lot of times, so you should use it here.
Here is how it would look like:
@bust.bitmap = Cache.picture("image file name goes here")This would assign an image from the folder Graphics/Pictures/ to the bitmap and will keep it in the memory for future uses until the game has been shut down.Look at the 'Cache' module at the top of the script list in the editor to see what kind of folders are available to use by default. You can create new usable folders by following the same format for your definition like the default ones in the 'Cache' module.
As soon as you assign an image to the bitmap assigned to the sprite, the image will appear on the screen.
Okay, now we know how to create the bust image. Now it is time to tie the correct images to the correct actors...
For this, we will jump into modules, and later, into another class.
First, create your module, name it however you like, but be sure to make it unique!
Example:
module Sixth_Battle_Busts # The contents of the module will go here!endWhen you are done, you can start to create your new, additional database.For the sake of flexibility, we will use a hash for creating the battle bust images.
Name it however you like.
A simple hash looks like this:
Example_Hash = { # <-- This kind of bracket indicates a hash! # The contents of the hash will go here!} # <-- This closes the hash, never forget this!Now we will populate the hash with the data needed for the bust images.For this, we will use the ID of the actors to name our keys in the hash. Keys are the names of the actual data.
Let's see what will we need for an image...
1. The file name of the image, obviously.
- This is defined with a simple string. Strings are enclosed by " signs.
2. Position of the image on the screen. # Optional for more flexibility!
- This is defined with integer numbers. We can use an array of 2 numbers for X and Y position.
3. The 'z' value for the image. # Optional for more flexibility!
- This is defined with integer numbers. The 'z' value affects what will be below the image and what will be above it.
4. The opacity value of the image. # Optional for more flexibility!
- This is defined with integer numbers. Valid values range from 0 to 255, 0 being fully transparent. This can be used to make the bust image a bit transparent, so that the player can still see what is behind the image in case something important can happen there.
So, let's see how would a complete setting look like for an actor:
1 => { :image => "actor1bust",
os => [120,230],
pacity => 255, :z => 150,},Notice the ' => ' signs. When you are in a hash, the thing from the left of that sign is the key/name of the setting while the thing on the right is the data it holds.Define a setting like this for each actor and you are done with creating your battle bust database.
Now to put this database to good use, we will use it in Game_Actor to initialize and assign the correct pictures for the correct actors.
Head over to 'Game_Actor' and in the 'initialize(actor_id)' method, you can use the 'actor_id' to assign the images to the actors.
So, how can we use the newly created database in methods?
Remember the module and hash name we used at the start? Well, we need to use that like this:
Sixth_Battle_Busts::Example_HashThis returns the entire database we just created.If you use this and make something like this in the initialize method:
@battle_bust = Sixth_Battle_Busts::Example_Hash[actor_id]We will assign the correct images to the correct actors.To make it able to read and overwrite this new data for the actors, we need to add a simple line immediately below the "class Game_Actor" line, outside of any method. It looks like this:
attr_accessor :battle_bustThis will make it possible to call for this new data outside of the current class.Notice that you need to make the same name for it like the name of the variable you used, but instead of a ' @ ' sign, you use a ' : ' sign before the name.
And finally we are ready to make the pictures appear in the battle! Yayy!
Remember the methods I mentioned at the start? Yeah, me neither!
So, they were 'next_command' and 'prior_command' in 'Scene_Battle'.
In both of them, you will need to call the new method we will create now.
Make the new method, name it something unique and let's start the process!
As I mentioned, we need to clear the bitmap before each command selection starts. What I mixed up was clear and dispose. We need to use dispose here. It should look like this:
@bust.bitmap.dispose if !@bust.bitmap.nil? && !@bust.bitmap.disposed?We automated the image change after each confirm/cancel with this.Now we are ready to assign the image to the bitmap:
@bust_data = BattleManager.actor.battle_bust@bust.bitmap = Cache.picture(@bust_data[:image])See the method I used? That is calling the new data we just made on the currently selecting actor. From that data, we select the name of the image only here, hence we use '[:image]' after the method call.Got the picture on the screen, hoorray!
Now we can add the optional things we defined (the position, opacity and z values) below this line:
@bust.x = @bust_data[
os][0]@bust.y = @bust_data[
os][1]@bust.opacity = @bust_data[
pacity]@bust.z = @bust_data[:z]Now we positioned the image where we wanted to, and added any additional properties we wanted to.But what if there is no currently selecting actor on the scene? Than we will get into trouble unless we make a check for it before we actually run the above mentioned image assigning lines.
A simple check will do the trick:
@bust.bitmap.dispose if !@bust.bitmap.nil? && !@bust.bitmap.disposed?if !BattleManager.actor.nil? # Do the above mentioned image assigning lines here! endSo, when there is no actor selecting commands, it will simply get rid of any images showing. How convenient!Okay, but there are some circumstances where the images should be get rid of outside of those two methods we just edited. That is the 'turn_start' method. When the last actor is finished the command selection, we need to make the last image disappear. Use the same method we used to do it.
And finally, we need to dispose our sprite and bitmap at the end of the battle.
You can do it in the 'dispose_spriteset' method in 'Scene_Battle' with these lines:
@bust.bitmap.dispose if !@bust.bitmap.nil? && !@bust.bitmap.disposed?@bust.dispose if !@bust.nil? && !@bust.disposed?And this is the basic of creating what you want.For making this thing happen in the right way, you will need to learn and use aliases or else there can, and there will most probably be some compatibility issues with other custom scripts used.
This explanation got bigger than I expected. o.o
I guess I will need to split it up into 2 posts... Let's see...
