For the Combat, Growth, Research, and Trade...
Here's a bit of psuedo-code. In fact, I'm basing it on my knowledge of Civilization, not MOO. Since I don't know how it works, it may or may not be the right code. Also, I'm typing this up as I go along. (sort of like notetaking in code)
Game loop
{
Player Loop
{
.
.
.
// When it's the end of the turn...
gameClass.UpdateGrowth(getCurrentPlayer());
gameClass.UpdateResearch(getCurrentPlayer());
.
.
.
}
}
In the gameClass file....
Growth
UpdateGrowth(int iPlayerIndex)
{
int j;
for(j=0;j<GetNumberOfCities(iPlayerIndex);j++) // This player has X cities...
{
CityClass.Owner[iPlayerIndex].City[j].Food += CountFoodSurplus(i);
if(CityClass.Owner[iPlayerIndex].City[j].Food > CityClass.Owner[iPlayerIndex].GetMaxFood(CityClass.Owner[iPlayerIndex].City[j].GetCitySize()))
{ // If there's an overflow, increase the size, and set the food to 0.
CityClass.Owner[iPlayerIndex].City[j].SetSize() += 1;
CityClass.Owner[iPlayerIndex].City[j].SetFood() = 0;
}
}
}
Tech
UpdateTech(int iPlayerIndex)
{
PlayerClass.Player[iPlayerIndex)].Tech.Research += CityClass.Owner[iPlayerIndex].GetTotalResearchBeakers();
if(PlayerClass.Player[iPlayerIndex)].Tech.Research > TechClass.GetNumBeakers(PlayerClass.Player[iPlayerIndex)].Tech.Index))
PlayerClass.Player[iPlayerIndex)].Tech.Add(PlayerClass.Player[iPlayerIndex)].Tech.Index);
PlayerClass.Player[iPlayerIndex)].Tech.Research = 0;
}
Combat
This one is kind of broad, and I'm not sure if you have to move a unit into another unit, or issue a command (like fire a missle 5 tiles away). Don't expect a combat engine in the lines of code I'm about to write.
Ok, in psuedo-code... Now, since you say you only have 2-3 months, I'm going to assume that unit stacking is out. It'll take more time than a simple 1 unit to 1 tile method.
// The player clicks a tile containing a unit. This triggers an event to show a menu of weapons.
// The player clicks a weapon. This triggers a "Select another tile" prompt.
// The player selects another tile... (assume that this is a function)
// The getMouseX/Y thing could be substituted for a better unit selection code if you want. I'm using "..." to denote possible code.
if(Map.bUnitExists(Graphics.GetMouseX(),Graphics.GetMouseY())
{
// It exists...
if( Map.bIsEnemy(FindOwner(Graphics.GetMouseX(),Graphics.GetMouseY()) )
{
Map.DoBattle(getAttacker(...),getDefender(...));
}
}
In the DoBattle() function...
void DoBattle()
{
// Since you've done a RPG game, I'm sure you're familiar with a battle engine..
}
Trade
I'm not sure how MOO works, but if it's like a diplomacy screen....
On the trade panels -
- For each NPC item, show the ones that the player doesn't have.
- For each player item, show the ones that NPC doesn't have
- Make two lists of items to be swapped.
- When the player confirms it, Delete the items in the player's swap list, and add the items in the NPC swap list, and vice versa.
Don't worry about AI yet, unless you want to do something simple like add up the values of the items to be traded and if the value is within X (maybe cost, or percentage), than the NPC will ok the trade.
---------------------
Your very first builds should look like they're a prototype. That is, a 2D screen (please don't tell me you're going 3D.
) where you can move, and dummy data that has X,Y coordinates that you can place on the map. If you must, generate units, ships, planets, etc. using code. (so you have have different colored planets/ships, etc. without having to make several files and worry about loading those files).
If I were coding this, my approach would be: (assuming I'm at the coding phase)
1 - Create the graphics class, and make sure that works. The graphics class will display the map, and in your main code, the ability to place units, ships and planets. (i.e., Graphics.PlacePlanet(x,y/*,z // if you want to be fancy and use 3D graphics, atleast make the object larger/smaller in scale... That's how I'd do 3D on a 2D engine. Granted, you'll have to make everything move towards/away from a central location in a conical shape.*/);
2 - Create the unit, improvement and planet classes (data gathering only - you're not deleting, updating or writing yet. It's only viewing the data.) and populate the unit/planet/improvement files with dummy data - maybe 1 or 2 items. Then, test it again with the graphics in place. (i.e., make sure that, using the main game file, you can display the data in some way, and that when you give a unit to the AI, it actually belongs to them.)
Note: I'd probably give the AI some super-unit at this point. 999 attack, 999 defense, 999 missiles, etc.
3 - Create the player class. Then, create your basic game loop.
while ( ... some game ending conditions are not met - save & quit, game over (player loses all units and planets, and so on), etc. ... )
{
.
.
.
doPlayer1Loop();
doUpdatePlayerStats();
doAILoop();
.
.
.
}
For doAiLoop(), I would make it a dummy function with a return 0; line. For the player loop, I would let the player control a unit until their turn is over.
4. Update the unit/city classes for algorithmic data. These would be things like get/set values (i.e., getPlanetName()..., setPlanetName(cName)... updatePlanet(...)). This is where you'd put any game features you want in your planet, such as soldiers being a percentage of the population.
Now, you should be able to go through the turns, and watch your galatic empire grow. Planets will grow, units and improvements will be built and healed. That's about all it can do right now. (units don't move at this point)
5. Give your units actions, including movement. You could also create a Fog of War at this point, too, but, I would actually place this (on the want/must scale of 1-5, with 5 being a much) at a 3. It's a cool feature, but if I only have 2 months to do this, it can wait. Now, if your unit finds the AI, it could do things like fire missles. Granted, I'm not sure how the battle system works. Is it 1vs1 like Civilization? Is it a "seek and destroy" where you can attack on the same map with short or long range weapons like Battleship? Or, does it go into its' own strategy screen that displays a fleet? Personally, this goes back to feasibility. With only 2-3 months, I'd opt for the simple method of "seek and destroy" (if you're close enough to the enemy, use an option) or "1vs.1" (if you bump into the enemy, attack). Create other basic features, like a simple attacking algorithm.
6. Create the user interface. At this point, many of the commands can be done with the mouse and keyboard. It always helps to have some sort of simple interface. The stuff that's on it could include a minimap, quick action buttons, and a menu. If time permits, a info-panel would be helpful to show quick information on a selected object.
Now, you may have an "interface" of sorts if you were displaying info to a section of the screen from step 2. That's fine if you want to keep it that way.
By now, you'd have a basic game where you can grow your planets, build units, explore and attack enemy units. Currently, there's only 1 enemy on the map, and 1 enemy unit (or planet if you wanted to give the AI a planet). You'll also have a simple interface to move around and see info in the game.
7 - Create multiple AI players. there'll still be a lack of AI code, but atleast you'll know that you can add/remove players. Speaking of which, if a player loses, you may want to remove whatever the player had left on the map. That way, you don't wind up fighting ghost ships (unless you want that, in which case, you might allow AI ships, but remove the crew).
8 - Create the main menu and sub menus for the game (New Game, Load Game, Hall of Fame, Exit...). "New Game" would lead to the game setup, where you can design the world (universe), and add players.
9 - Add in some rudimentary AI, and improve on any dummy-algorithms (like the battle engine). This includes things like battles, trade, exploration and growth.
Battle AI -
I would add some code that says, "Attack the weakest enemy unit with a weapon that will do the right amount of damage to defeat it". That way, I'm not having the AI attack a medical ship with a planet buster.
Trade AI -
I'd put in an algorithm that checks the value of the difference of items to be traded. If it's within a reasonable value, then do the trade. You could add a reputation system in where it makes it more/less likely that the AI will trade. An example would be this:
* Suppose the base difference was 500. Arbitrary number. A high reputation might expand that number to 2000, meaning you could rip the AI off if you wanted. A value of maybe, -300, would mean the AI's less likely to trade (200 value).
Exploration AI -
The AI could cheat and know where everything is, and just go to it. That might be the way to go for now, and if you have time, change it. It might involve something like keeping track of explored tiles and unexplored tiles, claiming valuable spots on the map, etc..
Growth AI -
I'm not sure how growth is done in MOO, but you could have the AI maybe focus on food (growth), and if it's an internal planet (not a border planet), then focus on production.
10 - If time permits, add or update any features. At this point, I might be wanting to check for bugs and gameplay issues.
)
