Need help brainstorming a tricky IMAGE issue

Question

Hi,
I've been trying to figure out a simple way around an issue, but as i simply cannot come up with an answer, i thought I'd put it out to the community to see if i can get some ideas back.
I'm putting a Mobile game together, and I'm still establishing the foundations of it. One element is the idea of having all creatures and character to be able to look different. To this end, my proposal is to have a set of various frames of say different creatures, and with other items (like armour and weapons) in matching poses. For example, You would have say a person running in 4 frames. For each frame, there is a matching set of clothes frames for each pose. One coule be normal clothes, and another armour so when the character is wearing normal clothes, the system would draw to the screen the naked character and then place the clothes over the top. Proper transparency (using the PNG alpha channel) makes this masking effect work as it should and it seems to work okay here.
Here is the problem. What i want to do is to be able to represent say, a hiding creature as being partially transparent wether through alpha blending or dithering. I have put an efficient class together than can quickly resize and recolour any image and draw it to the screen, and can also modify the transparency via either alpha blending or dithering. Here is the issue: This will NOT work when building the characters onto the screen! the problem if no-one notices here is lets say you then make the system draw the person at 50% opacity to the screen.Great, it works, but now we need to put the clothers on top so we draw THAT at 50% transparency. Uh-oh... Because the clothers are transparent, we get an artifact of the naked character shining through the clothers we just placed on top. So, the solution WOULD be simple: create an offscreen image for buffering, draw the character to it, then draw the results to the screen at 50% opacity... WRONG. The only Mutable off-screen image you can make is one filled with white pixels! Useless: we get an ugly white box around the character.
The only two solutions i can think of are the following:
1) Take a snapshot of the box around where we intend to draw the character. This should capture the background. We now build the character onto the screen as we normally would but if we want to make them transparent, we then paste the original background image over the top at a sertain opacity. I see problems with this being a) The design on the game is already very lean on memory requirements. I have built my own image handling classes that only load stuff when needed and discards it when no longer needed and also block wasteful reloading of images into memory, but having to always take a snapshot of a box around a character prior to drawing will slow it all down immensly.
2) the class i use for transformations, recolouring and resizing does so by copying the image data into an array and then manipulating it. I've designed it very well so that it only ever holds one image at a time and loading a new image into it uses the same array and thus, never creates a new array in memory and then relying on the Garbage collector to reclaim it. Using this, i could render the characters to it, and then draw it to screen but the problem as i see it is that this would be very processor intensive and would most likely slow the entire system down.
Naturally, the ideal solution is to draw to an offscreen image buffer and go from there, but i think the only way to do that is to use the BufferedImage which is on an API that isn't widely available (at least, it's not on my phone and it is pretty new). I need this to be as compatible as possible, so i don't want to access any optional API's i don't need to. I would prefer to be able to do this transparency trick, but if i can't, i guess i would have to find another way to represent a hiding character in the game (I guess a Black silouette).
Any help, hints or ideas would be greatly appreciated!

Answer 1

Okay, imagine you have a character running. The whole purpose of my design idea is to have it so the characters look different based on the gear they are equipped with (+Image a common game like Neverwinter nights, or WoW. Your character looks different based on what they are equipped with and no, I am not trying to create a game of that scale on a Mobile phone+). Naturally, the character isn't a static figure, so they move, run, attack and so fourth. My plan is to have a set of character frames in all the different frames, and matching clothes and equipment frames matching each cell (+we KNOW where their arm will be in the 2nd frame of a run-right action, so we would position say, a shield in the right spot. A clever appraoch is to be taken here for example, a right handed person would weild their shield in their left hand, and if they are running right, the shield would appear behind them and would be facing out, so the system would draw it in the order of "Left_Hand_Item->Character_in_the_Nude->Clothes_for_the_Character->Right_Hand_Item". Simple mirroring can handle any left/right directions as the frames for running in the different directions are also mirrored+). Essentially, the look of the character would need to be built on a per-frame basis. I am hessitant to build all of the frames of the character in memory at load time as I have the following action factors:
- The character can face in 8 directions being all the diagonals, Vertical and horizontal directions.
- The character needs the following actions to be available: Running, Standing, Dying -> On the ground (+This also counts falling down or sleeping+), Attacking / Swinging, Ranged attacks (+bow and arrow+).
- To at least offer some kind or animateable look, there should be at least 2 frames for each action.
As you can see, there is quite a lot. The approach i have already taken is fairly powerful. I decided to scrap the Java Sprites as it couldn't do what i needed it to do so i created my own caching system. A special MAP file stores the information on all the frames, and another class retrieves this on demand from the file, but only takes certain chunks. A initial class manages file access and loads the entire image into memory, and another uses this class to extract the frame it wants. When the other class is finished, the file-opening class then drops the full file from memory and attempts to reclaim the used memory. So far, it works well. The reason i have taken this appraoch is there is just too much data to have it all laoded into memory, it has to be done on demand and store as little information as possible. If i can represent 5 different characters by using a combination of other frames, i should have excellent results. I am trying to find a good balance between memory consumption and CPU usage. So, in a long winded answer:
--There are a LOT of frames that may need to be transparent at any one time.
--The amount of memory I'll need is still in the air at this point. As i build it, I am keeping a hawk-like eye on memory consumption and watching for anything being wasted (+using boolean where possible, If i don't need the capacity of an int, i use byte instead, etc+). This incidently ran me into the strong desire to utilize unsigned values as i don't need negatives anywhere, but I will have to live with that wasted bit.
--I am aware that not all devices support Alpha blending which is why I also aim to support dithering. For example at 50% transparency, more than half the pixels are fully transparent (+Some may already be transparent, so we're not going to go and make them visible!)+
--The transparent character is used to represent a character that is hiding. For example, you may have an Ally character being stealthy, so to make sure YOU the player can still see them, but represent clearly that they are in a special state, i wanted them to be transparent. Also, if there is an enemy stealthing, but you have detected them. I need to be able to represent that they have indeed been detected and that they can be seen, but they are still trying to be stealthy. So yes, one substitute would be to make them entirely black pixels and maybe even just draw the naked character black without any armour or equipment as a stealthing character would assume reduced detail.