My game is a strategy RPG. The Player at any given time has a team full of characters with as few as 3-4 and expanding to several dozen later in the game (though only some subset of these characters are necessarily "active"). In code, this translates to a Player object which owns up to several dozen instances of the Character class.
The character class has all sorts of functionality and data related to many aspects of the game. I was thinking about the fact that only a limited subset of the functionality available in the Character class is needed during a battle. My first implementation involved passing off control of the player's characters to a class called "Battle_Controller" which contains the map, a container of enemies, and so on and so forth. I started to think this wasn't a particularly good implementation.
My new thought is to create something like a "Battle_Character" class. The idea would be that its a smaller version of the Character class. The needed data would be obtained from the 'real' character at the start of a battle and the relevent methods from Character could be moved to Battle_Character. At the end of a battle the needed data could be sent back to the Player class and reintegrated with Character.
I like this implementation in one way as it seems like it aids encapsulation quite a bit as I'm no longer shuffling a whole lot of un-needed data and funtionality into and out of the Battle_Controller. On the other hand, it seems like I'm potentially creating a some very dependency laden code when it comes to obtaining and reintegrating data between the initial Character and the new Battle_Character.
I'm curious what people think, or if anyone has a third implementation option, I'd love to hear it. :)