In article <le**************@newsfe02.lga>,
ta*******@rocketmail.com
says...
In my program I am accepting messages over the network and parsing them. I
find that the function that does this has gotten quite big, and so want to
break the if else code into functions. I started thinking of how to do
this, but came up with a number of ways and don't know what would be best,
and fit into the C++ idoism.
[ ... ]
Over time this is just going to grow. This is the main text processing for
my online game and commands will only get added, not removed over time.
I can think of having a structure/class with Minimim GMLevel, keyword,
pointer to function call. There shouldn't be too much of a problem with
having to pass parameters to the class because of the game system constrains
I have a global structure that I can access what I need anyway.
What would be your suggestion?
A couple of minor suggestions: first of all, instead of making the block
of code functions, I'd probably make them class objects. They give you
more flexibility in the long run. You might not need it now, but the
penalty is low (a couple extra lines of code for each) and in the long
run the flexibility is likely to pay off. For simplicity, I'd probably
derive them all from a fairly simple base class.
Second, instead of making the framework directly aware of the GMLevel,
I'd probably have each of those functors include a "check" function or
something like that, that could look at a player object to determine
whether the player can carry out that action. Make it a virtual
function, and have the base class version simply check whether the
player's GMLevel is high enough -- but someday, when you decide an
action requires GMLevel X _and_ the player to be carrying object Y (or
whatever) it'll be easy to handle. Again, the penalty now is minimal,
and the long-term payoff is potentially fairly high.
You also mentioned using a custom map type -- nothing you've said
convinces me that you need anything std::map doesn't provide. The
keyword is the key for your map, and the value type will be a pointer to
the "action" object. From what you've said so far, the base class would
look something like this:
class player;
class action {
int req_GMLevel;
public:
virtual bool check(player const &p) {
return p->GMLevel>= req_GMLevel;
}
virtual void exec() = 0;
}
From there your framework looks something like this:
// Do a case-insensitive comparison to avoid repeating comparisons,
// as well as allowing, e.g., "/List" along with "/list" and "/LIST"
//
struct cmp {
// Q&D case-insensitive comparison: convert a copy of each
// string to upper case, and compare those copies:
//
bool operator()(std::string a, std::string b) {
std::transform(a.begin(), a.end(), a.begin(), std::toupper);
std::transform(b.begin(), b.end(), a.begin(), std::toupper);
std::string::size_type len = b.size();
return a.compare(0, len, b) == 1;
}
};
// We'll be using this a couple of times and don't want to re-type it:
typedef std::map<std::string, action *, cmpactions_map;
// The actual map from command names to actions:
actions_map actions;
// Create our actual actions. Each must override execute().
// Each can override check() if more complex criteria ever arise
// for qualifying a player to carry out a particular action:
class lister : public action { /* ... */ } list;
class summoner: public action { /* ... */ } summon;
class jumper : public action { /* .. .*/ } jump;
// 27 more action classes here...
// Set up the map from commands to actions:
actions["/list"] = &list;
actions["/summon"] = &summon;
actions["/jumpto"] = &jump;
// 27 more command/action pairs here...
// Execute a command from the user:
//
// look the command up in the map
actions_map::iterator it = actions.find(strMessage);
// if it wasn't found, tell the user:
if (actions.end() == it)
std::cerr<<"Sorry, I don't understand: \""<< strMessage<<"\"\n";
// it was found; check whether the player can do that
else if (it->second.check(player)))
// and if so, do it.
it->second.execute();
else
// otherwise, tell them they can't.
std::cerr << "Sorry, you can't do that\n";
--
Later,
Jerry.
The universe is a figment of its own imagination.
