[Java-sig] Where to go past "hello world"?

[Emerson, Tom]

Does anyone have a specific goal in mind?  Any particular problem you
need solved where "Java" fits the bill as the language in which it
should be implemented?

If not, I'd like to suggest a (relatively) simple game (compared to
top-of-the-line/state-of-the-art blockbusters out there ;) )

The game I have in mind, or rather, the class of games, would be
"Hamurabi".  For those not familiar with 101 basic games, the premise is
simple: you're the ruler of the kingdom of Hamurabi; each year your
administrative staff comes to you for advice -- how many acres of land
to plant, how much to tax to levy, how much to spend on healthcare, and
so on.  After retrieving your inputs, the game calculates "a cycle" (one
year) and tells you how many people were born, died (of starvation
and/or disease), immigrated/emigrated; how much (surplus) gain was
stored vs. how much spoiled (or eaten by rats), or if demand exceeded
supply.  Your "score" is the population and/or treasury balance.

You'll notice I said "class of games" -- there are other very similar
games out there: lemonade stand, coffee tycoon, (in fact, all the
"tycoon" games to some extent) that all work off the same premise: you
make decisions about raw materials (lemons, coffee, acres to plant), how
much to charge (selling price, tax), and the game goes through some
"magic calculation" to determine profit/loss (population,
taxes/treasury).  For the Hamurabi game in particular, knowing the
internal values (i.e. x bushels of grain supports y people, spoils at a
rate of z%, etc.) allows you to back-calculate the optimum number to
plant to feed your people, tax accordingly, and grow your
income/treasury.  Of course, knowing these values in such great detail
makes the game less enjoyable (there's no suspense to the outcome) so
later versions and variations add more variables and/or randomness to
the factors (or in the sim-whatever and whatever-tycoon games, forces
you to make decisions "in real time") so that "as a human", you couldn't
possibly calculate the "optimum" values for every setting or scenario.

What makes this worthwhile as a study goal is that it doesn't have to
have "fancy graphics", "3-d interface", and so on -- just a way to get
inputs and a way to display the results (it is a console/terminal based
program to begin with...)  And although the original was in "BASIC",
being that it is a "simulation", it lends itself well to being done
"with objects" (raw material object, storage object, etc.) without
concern for what those objects are (lemons vs. coffee beans)

Hmmm... I've gone on a little longer than I intended -- what I really
wanted to know was: is there interest among the group as a whole to
consider this, or should I make this my own personal goal?  (i.e., a
"Hamurabi engine" in Java)