How does the A.I. think?

Basically, the computer opponents "want" the same thing as the player - to conquer the world.

However, their current formula to detirmine how to do that is pretty unadvanced currently.

The first step in the turn of each A.I. is to detirmine whether or not it is wise to attack one of one's neighbors. This is accomplished as follows :

function determine_defender(countries, ind_att)
{
var ind_defender = -1;
var ind;

//determine country with minimum count of men
var min = countries[ind_att].men; //default
var nbr = countries[ind_att].nbr;

for(ind = 0; ind < nbr.length; ++ind)
{
if( (countries[ind_att].objleader.leader != countries[nbr[ind]].objleader.leader)
&& (countries[ind_att].men > (countries[nbr[ind]].men * 1.5) )
&& (countries[nbr[ind]].men < min) )
{
min = countries[nbr[ind]].men;
ind_defender = nbr[ind];
}
}

return ind_defender;
}

Ok. I won't pretend to know exactally what all this coding means since it was not written by me, but what I do understand is that somehow the neighbors (adjacent countries to the nation whose turn it is) are scanned. Only the one with the smallest amount of troops is a possible target. And the nation only becomes a potential target if the attacker nation has at least 1.5 times as many troops (in their country, not necessarily all to be used in the attack).

function should_fight(att, def)
{
var percent = Math.floor( (att.men / def.men) * 10.0);

if (percent > 25)
{
percent += 5
}
else
{
percent -= 5
}
if ( ((att.economy + att.gold) / (def.economy + def.gold)) > 2)
percent-=15;
else if ( (def.economy + def.gold) >= ((att.economy + att.gold) * 2) )
percent+=15;

var random = Math.floor( ( (Math.random() * 2000000) % 100) + 1);

if (percent > random) return true;
else return false;
}

What is first happening here is that the computer divides the attacker's men by the defender's and multiplies by 10. So for example the attack has 150 men is his home country and the attacker has 50, so (150/50) * 10 = 30. 30 becomes the variable percent (to detirmined the percentage likelihood of attack).

Second step : If percent is greater than 25 then it automatically jumps up 5. So percent is now 35.

Now, third step : If the target (potential defender) country is particularly rich (double the economy and gold of the attacker) the chances of attack go up 15%. If twice as poor (less or equal to half of the attacker countries econ + gold) attack chances go down 15%. If neither applies the percent chance of attack remains the same.

Just for fun we'll say the defender is indeed twice as wealthy. So now the chance has risen to an even 50%. A random number is selected. If over 50 the attack is not made and the A.I. develops his nation (trains, builds, hires or moves) instead. If under 50... the battle rages...

var g_att, g_def, g_att_assigned, g_total_skill;

function fight(att, def)
{
var outstr = '';
var att_force_random = Math.floor( ( (Math.random() * 2000000) % 11) + 1);
att_force_random = att_force_random / 100
att_force_random = att_force_random + .64
var att_assigned = Math.floor(att.men * att_force_random); //between 65 and 75% of soldiers attack
att.men -= att_assigned //deduct men from attacking country
var total_skill = att.skill + def.skill;

txtBattles.innerHTML = ''; BattleStats.innerHTML = '';
outstr += att.objleader.leader + ' from ' + att.name + ' has invaded ' ;
outstr += def.objleader.leader + ' in ' + def.name + '!! <BR/>' ;
print_stats(gcountries);

//<embed src="SWRDHORS.AIFF" autostart="true" loop="false" hidden=true></embed>

txtBattles.innerHTML += outstr + 'The Battle rages....<BR/>' ;

g_att = att; g_def = def; g_att_assigned = att_assigned; g_total_skill = total_skill;
fight_men();
}

First step now is detirmine how many men from the attacking nation are actually going to war. Obviously the attacker can't send them all or he'd be defenseless himself to other neighbors (unless he was surrounded by only friendly/his own nations).

So the computer generates a random number between one and 11 and adds to to 64 and thus between 65 and 75% of the attacker's forces come to fight while the rest remain home to guard the motherland.

function fight_men()
{
var outstr = '';

if( (g_att_assigned > 0) && (g_def.men > 0) )
{
var random = Math.floor( (Math.random() * 2000000) % g_total_skill + 1);
if (random <= g_att.skill)
{
g_def.men -= 1;

}
else
{
g_att_assigned -= 1;

}
}

if (g_def.men == 0) //attacker won
{
g_def.skill = g_att.skill + 5 //attacker's skill rises 5 points
g_def.men += g_att_assigned; //attackers men stay to protect defeated country
outstr += g_def.objleader.leader + "\'s army has been defeated. <BR/>";
outstr += 'Country ' + g_def.name + ' passes to ' + g_att.objleader.leader + '<BR/>' ;
--(g_def.objleader.count) ;
++(g_att.objleader.count);
if (g_def.objleader.count == 0) outstr += '<font color="red">' + g_def.objleader.leader + ' has been annihilated! <font color="black"> <BR/>' ;
g_def.objleader = g_att.objleader; //country changes hands
document.all("im" + g_def.name).src = document.all("im" + g_att.name).src;
document.all("im" + g_def.name).width = document.all("im" + g_att.name).width;
document.all("im" + g_def.name).height = document.all("im" + g_att.name).height;
document.all("im" + g_def.name).style.top = g_def.y - (document.all("im" + g_def.name).height /2);
document.all("im" + g_def.name).style.left = g_def.x - (document.all("im" + g_def.name).width /2);
print_stats();
//eval("im_" + g_def.name + ".src= g_att.objleader.colorfile");
setTimeout("BattleStats.innerHTML = ''",1000);
picBattle.style.display = "none";
if (g_ind_att < CNT_COUNTRIES - 1)
setTimeout("goCountry(" + (g_ind_att + 1) + ")",2500);
else
{
g_ind_att = 0;
runRound();
}
}
else if(g_att_assigned == 0) //defender won
{
g_def.skill += 5;
outstr += g_att.objleader.leader + "\'s army has been defeated.<BR/>";
outstr += g_def.objleader.leader + ' holds on to ' + g_def.name + '<BR/>';
setTimeout("BattleStats.innerHTML = ''",1000);
picBattle.style.display = "none";
if (g_ind_att < CNT_COUNTRIES -1)
setTimeout("goCountry(" + (g_ind_att + 1) + ")",2500);
else
{
g_ind_att = 0;
runRound();
}

}
else
setTimeout("fight_men()", 1);

txtBattles.innerHTML += outstr;
}

Despite all the code (a lot of it updating stats and displaying information onscreen) the battle process is beautifully simple. The attacker and defender skills are added up and a random number between 1 and the sum of their totals is created. If that number falls between 1 and the attacker's skill then the defender loses a man, if it's higher the defneder loses one. The fight goes on like this until one of the nations loses all their troops.

function prepare(att, selchoice, selvalue)
{
var choice;
var args;
var max_eco = 5000;

if (args > 1)
choice = selchoice;
else
{
if ( NoHostileNbrs(att) && att.men >=50 )
choice = 4;
else if (att.men < 25)
choice = 1;
else if (att.economy == max_eco)
choice = Math.floor( (Math.random() * 2000000) % 2 + 1 );
else
choice = Math.floor( (Math.random() * 2000000) % 3 + 1 );
}

var hire = 0, outstr='';

outstr = '<img align="left" src="' + att.objleader.leader + '.gif"/><BR/>';
outstr += "Country " + att.name + ', ' + att.objleader.leader + "\'s turn<BR/>";
outstr += att.objleader.leader + ' moves ';
switch(choice)
{
case 1:
hire = Math.floor(att.gold / get_price_man() );
att.men += hire;
att.gold -= hire * get_price_man();
break;

case 2:
random = Math.floor( (Math.random() * 2000000) % 3 + 1);
att.skill += 3 + random; //goes up to 4-6 points
break;

case 3:
var diff = (max_eco - att.economy) * 2;
if (diff < att.gold)
{
att.gold-=diff;
att.economy = max_eco;
}
else
{
att.economy += Math.floor(att.gold / 2);

if( Math.floor(att.gold/2) < att.gold/2)
att.gold=1;
else
att.gold = 0;

}
break;

case 4:
var indnbr = Math.floor( (Math.random() * 2000000) % att.nbr.length + 1);
gcountries[att.nbr[indnbr - 1]].men += att.men - 25 ;
att.men= 25;
}

print_stats(gcountries);
txtActions.innerHTML += outstr;
}

Now the majority of A.I. turns are not going to be battles. The rest of the time the AI will either train, hire or build into their economy. They will also automatically transfer troops to an adjancent territory if (A) There are no hostile neighbors to attack and (B) They have 50 troops or more in their country.

Also, the Economy rate maxes out at 5000 so if the economy is at that level then the AI will choose only between hiring and training.

Outside of these exceptions the AI will randomly hire, train or build. Their chances of doing any one of these three is 33.33333etc%.