home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 366.lha / CosmicConquest_v1.035 / klingon.c < prev    next >
Encoding:
Text File  |  1990-04-08  |  12.4 KB  |  471 lines
  1. klingon(pla)
  2. int pla;
  3.   {
  4.   struct NCommand c;
  5.   int i,j,k,shi,shival,sta,sta2,tas,p,dis;
  6.   /*Join all tasks at all stars*/
  7.   c.com=JOIN;
  8.   for(sta=0;sta<STARNO;sta++)
  9.     if(knowstar(pla,sta))
  10.     {
  11.     j=0;
  12.     for(i=0;i<TASKNO;i++) if (ATSTAR(pla,i,sta)) c.par[j++]=i;
  13.     c.par[j]=TASKNO;
  14.     if (j>1) do_command(pla,&c);
  15.     }
  16.   /* Uncarry all ships*/
  17.   c.com=CARRY;
  18.   for(shi=0;shi<SHIPNO;shi++) c.par[shi+1]=0;
  19.   for(tas=0;tas<TASKNO;tas++)
  20.     if(task[pla][tas].headed!=-1 && task[pla][tas].arriving<=general.time)
  21.       {
  22.       c.par[0]=tas;
  23.       do_command(pla,&c);
  24.       }
  25.   /* Declare war at all who have declared war*/
  26.   c.com=DECLARE;
  27.   c.par[1]=WAR;
  28.   for(i=0;i<PLAYERNO;i++)
  29.     if (i!=pla && general.relation[i][pla]==WAR && general.relation[pla][i]!=WAR)
  30.       {
  31.       c.par[0]=i;
  32.       do_command(pla,&c);
  33.       }
  34.   /* Declare war on concurrents and possess all planets*/
  35.   for(tas=0;tas<TASKNO;tas++)
  36.     {
  37.      if(task[pla][tas].headed==-1 || task[pla][tas].arriving>general.time) continue;
  38.     sta=task[pla][tas].headed;
  39.     for(i=0;i<PLAYERNO;i++)
  40.       if(i!=pla && search_task(i,sta)!=TASKNO && general.relation[i][pla]==PEACE)
  41.         {
  42.         c.com=DECLARE;
  43.         c.par[0]=i;
  44.         c.par[1]=WAR;
  45.         do_command(pla,&c);
  46.         }
  47.     for(p=0;p<PLANETNO;p++)
  48.       if(star[sta].planet[p].population>0 && star[sta].planet[p].ruler!=pla)
  49.         {
  50.         c.com=POSSESS;
  51.         c.par[0]=sta;
  52.         c.par[1]=p;
  53.         do_command(pla,&c);
  54.         }
  55.     }
  56.   /* Declare War on invaders */
  57.   c.com=DECLARE;
  58.   c.par[1]=WAR;
  59.   for(sta=0;sta<STARNO;sta++) if(knowstar(pla,sta)) for(p=0;p<PLANETNO;p++)
  60.     if(star[sta].planet[p].poptype==pla && star[sta].planet[p].ruler!=pla)
  61.       {
  62.       c.par[0]=star[sta].planet[p].ruler;
  63.       do_command(pla,&c);
  64.       }
  65.   /* Land Tasks */
  66.   c.com=LAND;
  67.   for(tas=0;tas<TASKNO;tas++)
  68.     {
  69.     if(task[pla][tas].headed==-1 || task[pla][tas].arriving>general.time) continue;
  70.     sta=task[pla][tas].headed;
  71.     c.par[0]=tas;
  72.     for(p=0;p<PLANETNO;p++)
  73.       {
  74.       if(task[pla][tas].ship_free[POPUNIT]+task[pla][tas].ship_free[OREUNIT]==0) continue;
  75.       if(star[sta].planet[p].ruler!=pla && star[sta].planet[p].population>0) continue;
  76.       if(star[sta].planet[p].size==0) continue;
  77.       if(star[sta].planet[p].size<=star[sta].planet[p].industry) continue;
  78.       c.par[1]=p;
  79.       do_command(pla,&c);
  80.       }
  81.     }
  82.   /* Set production on all planets*/
  83.   c.com=PRODUCE;
  84.   for(sta=0;sta<STARNO;sta++) for(p=0;p<PLANETNO;p++)
  85.     if(star[sta].planet[p].ruler==pla && star[sta].planet[p].industry!=0 && star[sta].planet[p].ipoints<star[sta].planet[p].industry)
  86.     {
  87.     c.par[0]=sta;
  88.     c.par[1]=p;
  89.     tas=search_task(pla,sta);
  90.     if(star[sta].planet[p].mineable)
  91.       {
  92.       c.par[2]=MINING;
  93.       if(star[sta].planet[p].producing!=c.par[2]) do_command(pla,&c);
  94.       continue;
  95.       }
  96.     if(5*fi_need(pla,sta)/4>fi_pres(pla,sta))
  97.       {
  98.       c.par[2]=best_fi(pla,sta);
  99.       if(star[sta].planet[p].producing!=c.par[2]) do_command(pla,&c);
  100.       continue;
  101.       }
  102.     if(tr_need(pla,sta)>tr_pres(pla,sta))
  103.       {
  104.       c.par[2]=best_tr(pla,sta);
  105.       if(star[sta].planet[p].producing!=c.par[2]) do_command(pla,&c);
  106.       continue;
  107.       }
  108.     if(star[sta].planet[p].industry+star[sta].planet[p].industry/ICOST<star[sta].planet[p].population)
  109.       {
  110.       c.par[2]=INVESTING;
  111.       if(star[sta].planet[p].producing!=c.par[2]) do_command(pla,&c);
  112.       continue;
  113.       }
  114.     c.par[2]=RESEARCHING;
  115.     if(star[sta].planet[p].producing!=c.par[2]) do_command(pla,&c);
  116.     }
  117.   /* Send all fighting taskforces */
  118.   for(tas=0;tas<TASKNO;tas++) if((sta=task[pla][tas].headed)!=-1 && task[pla][tas].arriving<=general.time)
  119.     while(fi_pres(pla,sta)>fi_need(pla,sta))
  120.     {
  121.     sta2=fi_star(pla,sta);
  122.     if(sta2==-1) break;
  123.     dis=distance(sta,sta2);
  124.     i=fi_pres(pla,sta )-fi_need(pla,sta );
  125.     j=fi_need(pla,sta2)-fi_send(pla,sta2);
  126.     k=fi_pres(pla,sta )-fi_need(pla,sta );
  127.     i=MIN(i,j);
  128.     j=0;
  129.     c.com=SPLIT;
  130.     c.par[0]=tas;
  131.     for(shi=0;shi<SHIPNO;shi++) c.par[shi+1]=0;
  132.     shi=0;
  133.     while(j<i && shi!=SHIPNO)
  134.       for(shi=0;shi<SHIPNO;shi++)
  135.         if(task[pla][tas].ship_free[shi]>c.par[shi+1] && ship[shi].hyprange>=dis && fi_value(shi)<=k && fi_value(shi)!=0)
  136.           {
  137.           c.par[shi+1]++;
  138.           j+= fi_value(shi);
  139.           k-= fi_value(shi);
  140.           break;
  141.           }
  142.     for(shi=0;shi<SHIPNO;shi++) if(c.par[shi+1]!=0) break;
  143.     if(shi==SHIPNO) break;
  144.     c.par[0]=do_command(pla,&c);
  145.     if(c.par[0]==-1) break;
  146.     c.com=DESTINATION;
  147.     c.par[1]=sta2;
  148.     if(do_command(pla,&c)==-1) break;
  149.     }
  150.   /* Send POPUNITS */
  151.   for(tas=0;tas<TASKNO;tas++) if((sta=task[pla][tas].headed)!=-1 && task[pla][tas].arriving<=general.time)
  152.     while(pop_pres(pla,sta)>pop_need(pla,sta))
  153.     {
  154.     sta2=pop_star(pla,sta);
  155.     if(sta2==-1) break;
  156.     dis=distance(sta,sta2);
  157.     i=pop_pres(pla,sta )-pop_need(pla,sta );
  158.     j=pop_need(pla,sta2)-pop_send(pla,sta2);
  159.     i=MIN(i,j);
  160.     j=0;
  161.     k=fi_pres(pla,sta)-fi_need(pla,sta);
  162.     c.com=SPLIT;
  163.     c.par[0]=tas;
  164.     for(shi=0;shi<SHIPNO;shi++) c.par[shi+1]=0;
  165.     shi=0;
  166.     while(i>j && shi!=SHIPNO)
  167.       for(shi=0;shi<SHIPNO;shi++)
  168.         if(task[pla][tas].ship_free[shi]>c.par[shi+1] && ship[shi].hyprange>=dis && (k>=fi_value(shi)||fi_value(shi)<=0) && ship[shi].capacity>0)
  169.           {
  170.           c.par[shi+1]++;
  171.           j+= ship[shi].capacity;
  172.           k-= fi_value(shi);
  173.           break;
  174.           }
  175.     for(shi=0;shi<SHIPNO;shi++) if(c.par[shi+1]!=0) break;
  176.     if(shi==SHIPNO) break;
  177.     i=MIN(i,j);
  178.     c.par[POPUNIT+1]=MIN(i,task[pla][tas].ship_free[POPUNIT]);
  179.     c.par[0]=do_command(pla,&c);
  180.     if(c.par[0]==-1) break;
  181.     c.com=DESTINATION;
  182.     c.par[1]=sta2;
  183.     if(do_command(pla,&c)==-1) break;
  184.     }
  185.   /* Send OREUNITS */
  186.   for(tas=0;tas<TASKNO;tas++) if((sta=task[pla][tas].headed)!=-1 && task[pla][tas].arriving<=general.time)
  187.     while(ore_pres(pla,sta)>ore_need(pla,sta))
  188.     {
  189.     sta2=ore_star(pla,sta);
  190.     if(sta2==-1) break;
  191.     dis=distance(sta,sta2);
  192.     i=ore_pres(pla,sta )-ore_need(pla,sta );
  193.     j=ore_need(pla,sta2)-ore_send(pla,sta2);
  194.     i=MIN(i,j);
  195.     j=0;
  196.     k=fi_pres(pla,sta)-fi_need(pla,sta);
  197.     c.com=SPLIT;
  198.     c.par[0]=tas;
  199.     for(shi=0;shi<SHIPNO;shi++) c.par[shi+1]=0;
  200.     shi=0;
  201.     while(i>j && shi!=SHIPNO)
  202.       for(shi=0;shi<SHIPNO;shi++)
  203.         if(task[pla][tas].ship_free[shi]>c.par[shi+1] && ship[shi].hyprange>=dis && (k>=fi_value(shi)||fi_value(shi)<=0) && ship[shi].capacity>0)
  204.           {
  205.           c.par[shi+1]++;
  206.           j+= ship[shi].capacity;
  207.           k-= fi_value(shi);
  208.           break;
  209.           }
  210.     for(shi=0;shi<SHIPNO;shi++) if(c.par[shi+1]!=0) break;
  211.     if(shi==SHIPNO) break;
  212.     i=MIN(i,j);
  213.     c.par[OREUNIT+1]=MIN(i,task[pla][tas].ship_free[OREUNIT]);
  214.     c.par[0]=do_command(pla,&c);
  215.     if(c.par[0]==-1) break;
  216.     c.com=DESTINATION;
  217.     c.par[1]=sta2;
  218.     if(do_command(pla,&c)==-1) break;
  219.     }
  220.   /* Send all empty transporters */
  221.   for(tas=0;tas<TASKNO;tas++) if((sta=task[pla][tas].headed)!=-1 && task[pla][tas].arriving<=general.time)
  222.     while(tr_pres(pla,sta)>tr_need(pla,sta))
  223.     {
  224.     sta2=tr_star(pla,sta);
  225.     if(sta2==-1) break;
  226.     dis=distance(sta,sta2);
  227.     i=tr_pres(pla,sta )-tr_need(pla,sta );
  228.     j=tr_need(pla,sta2)-tr_send(pla,sta2);
  229.     i=MIN(i,j);
  230.     j=0;
  231.     k=fi_pres(pla,sta)-fi_need(pla,sta);
  232.     c.com=SPLIT;
  233.     c.par[0]=tas;
  234.     for(shi=0;shi<SHIPNO;shi++) c.par[shi+1]=0;
  235.     shi=0;
  236.     while(i>j && shi!=SHIPNO)
  237.       for(shi=0;shi<SHIPNO;shi++)
  238.         if(task[pla][tas].ship_free[shi]>c.par[shi+1] && ship[shi].hyprange>=dis && (k>=fi_value(shi)||fi_value(shi)<=0))
  239.           {
  240.           c.par[shi+1]++;
  241.           j+= ship[shi].capacity;
  242.           k-= fi_value(shi);
  243.           break;
  244.           }
  245.     for(shi=0;shi<SHIPNO;shi++) if(c.par[shi+1]!=0) break;
  246.     if(shi==SHIPNO) break;
  247.     c.par[0]=do_command(pla,&c);
  248.     if(c.par[0]==-1) break;
  249.     c.com=DESTINATION;
  250.     c.par[1]=sta2;
  251.     if(do_command(pla,&c)==-1) break;
  252.     }
  253.   }
  254. fi_star(pla,sta)
  255. int pla;
  256. int sta;
  257.   {
  258.   int st,b_sta,b_dist;
  259.   b_sta=-1;
  260.   b_dist=1000;
  261.   for(st=0;st<STARNO;st++)
  262.     if(distance(st,sta)<=b_dist && fi_need(pla,st)>fi_send(pla,st))
  263.     {
  264.     b_sta=st;
  265.     b_dist=distance(st,sta);
  266.     }
  267.   return(b_sta);
  268.   }
  269. tr_star(pla,sta)
  270. int pla;
  271. int sta;
  272.   {
  273.   int st,b_sta,b_dist;
  274.   b_sta=-1;
  275.   b_dist=1000;
  276.   for(st=0;st<STARNO;st++)
  277.     if(distance(st,sta)<=b_dist && tr_need(pla,st)>tr_send(pla,st))
  278.     {
  279.     b_sta=st;
  280.     b_dist=distance(st,sta);
  281.     }
  282.   return(b_sta);
  283.   }
  284. fi_need(pla,sta)
  285. int pla;
  286. int sta;
  287.   {
  288.   int p,pl,need;
  289.   need=1;
  290.   if(!knowstar(pla,sta)) return(need);
  291.   for(p=0;p<PLANETNO;p++)
  292.     {
  293.     need+=(star[sta].planet[p].mineable+1)*star[sta].planet[p].size/10;
  294.     need+=star[sta].planet[p].population/10;
  295.     need+=star[sta].planet[p].industry/10;
  296.     }
  297.   need *= general.techlevel[pla]/100;
  298.   need += CommData[pla].star[sta].danger;
  299.   return(need);
  300.   }
  301. fi_send(pla,sta)
  302. int pla;
  303. int sta;
  304.   {
  305.   int send;
  306.   int tas,shi;
  307.   send=0;
  308.   for(tas=0;tas<TASKNO;tas++) if(task[pla][tas].headed==sta)
  309.     for(shi=0;shi<SHIPNO;shi++) send+=task[pla][tas].ship_free[shi]*fi_value(shi);
  310.   return(send);
  311.   }
  312. best_fi(pla,sta)
  313. int pla;
  314. int sta;
  315.   {
  316.   int b_shi,b_val,shi,dis;
  317.   dis=distance(sta,nearstar(sta));
  318.   b_shi=-1;b_val=0;
  319.   for(shi=0;shi<SHIPNO;shi++)
  320.     if(ship[shi].hyprange>=dis && ship[shi].techlevel<=general.techlevel[pla]
  321.        && (20*fi_value(shi))/ship[shi].techcost>b_val)
  322.       {
  323.       b_shi=shi;
  324.       b_val=20*fi_value(shi)/ship[shi].techcost;
  325.       }
  326.   return(b_shi);
  327.   }
  328. tr_need(pla,sta)
  329. int pla;
  330. int sta;
  331.   {
  332.   int shi,tas,p,pl,need,dis;
  333.   need=0;
  334.   dis=distance(sta,nearstar(sta));
  335.   if(!knowstar(pla,sta)) return(0);
  336.   for(tas=0;tas<TASKNO;tas++) if(ATSTAR(pla,tas,sta))
  337.     for(shi=0;shi<SHIPNO;shi++) if(ship[shi].hyprange<dis)
  338.        need += ship[shi].size*task[pla][tas].ship_free[shi];
  339.   return(need);
  340.   }
  341. tr_pres(pla,sta)
  342. int pla;
  343. int sta;
  344.   {
  345.   int pres,tas;
  346.   pres=0;
  347.   for(tas=0;tas<TASKNO;tas++) if(ATSTAR(pla,tas,sta)) pres += task_capa(pla,tas);
  348.   return(pres);
  349.   }
  350. tr_send(pla,sta)
  351. int pla;
  352. int sta;
  353.   {
  354.   int send,tas;
  355.   send=0;
  356.   for(tas=0;tas<TASKNO;tas++) if(task[pla][tas].headed==sta) send += task_capa(pla,tas);
  357.   return(send);
  358.   }
  359. tr_value(shi)
  360. int shi;
  361.   {
  362.   return(ship[shi].hypspeed*ship[shi].capacity);
  363.   }
  364. best_tr(pla,sta)
  365. int pla;
  366. int sta;
  367.   {
  368.   int b_shi,b_val,shi,dis;
  369.   dis=distance(sta,tr_star(pla,sta));
  370.   b_shi=RESEARCHING;b_val=0;
  371.   for(shi=0;shi<SHIPNO;shi++)
  372.     if(ship[shi].hyprange>=dis && ship[shi].techlevel<=general.techlevel[pla]
  373.        && (20*tr_value(shi))/ship[shi].techcost>b_val)
  374.       {
  375.       b_shi=shi;
  376.       b_val=20*tr_value(shi)/ship[shi].techcost;
  377.       }
  378.   return(b_shi);
  379.   }
  380. pop_pres(pla,sta)
  381. int pla;
  382. int sta;
  383.   {
  384.   int pres,tas;
  385.   pres=0;
  386.   for(tas=0;tas<TASKNO;tas++) if(ATSTAR(pla,tas,sta))
  387.     pres += task[pla][tas].ship_free[POPUNIT]+task[pla][tas].ship_load[POPUNIT];
  388.   return(pres);
  389.   }
  390. pop_need(pla,sta)
  391. int pla;
  392. int sta;
  393.   {
  394.   int need,p;
  395.   need=0;
  396.   for(p=0;p<PLANETNO;p++) if((star[sta].planet[p].ruler==pla && star[sta].planet[p].poptype==pla)
  397.                              || star[sta].planet[p].ruler==PLAYERNO)
  398.     need += star[sta].planet[p].size-star[sta].planet[p].population;
  399.   return(need);
  400.   }
  401. pop_send(pla,sta)
  402. int pla;
  403. int sta;
  404.   {
  405.   int send,tas;
  406.   send=0;
  407.   for(tas=0;tas<TASKNO;tas++) if(task[pla][tas].headed==sta)
  408.     send += task[pla][tas].ship_load[POPUNIT]+task[pla][tas].ship_free[POPUNIT];
  409.   return(send);
  410.   }
  411. pop_star(pla,sta)
  412. int pla;
  413. int sta;
  414.   {
  415.   int st,b_sta,b_dist;
  416.   b_sta=-1;
  417.   b_dist=1000;
  418.   for(st=0;st<STARNO;st++)
  419.     if(distance(st,sta)<=b_dist && pop_need(pla,st)>pop_send(pla,st))
  420.     {
  421.     b_sta=st;
  422.     b_dist=distance(st,sta);
  423.     }
  424.   return(b_sta);
  425.   }
  426. ore_pres(pla,sta)
  427. int pla;
  428. int sta;
  429.   {
  430.   int pres,tas;
  431.   pres=0;
  432.   for(tas=0;tas<TASKNO;tas++) if(ATSTAR(pla,tas,sta))
  433.     pres += task[pla][tas].ship_free[OREUNIT]+task[pla][tas].ship_load[OREUNIT];
  434.   return(pres);
  435.   }
  436. ore_need(pla,sta)
  437. int pla;
  438. int sta;
  439.   {
  440.   int need,p;
  441.   need=0;
  442.   for(p=0;p<PLANETNO;p++) if(star[sta].planet[p].ruler==pla)
  443.     need += star[sta].planet[p].population-star[sta].planet[p].industry;
  444.   return(need);
  445.   }
  446. ore_send(pla,sta)
  447. int pla;
  448. int sta;
  449.   {
  450.   int send,tas;
  451.   send=0;
  452.   for(tas=0;tas<TASKNO;tas++) if(task[pla][tas].headed==sta)
  453.     send += task[pla][tas].ship_free[OREUNIT]+task[pla][tas].ship_load[OREUNIT];
  454.   return(send);
  455.   }
  456. ore_star(pla,sta)
  457. int pla;
  458. int sta;
  459.   {
  460.   int st,b_sta,b_dist;
  461.   b_sta=-1;
  462.   b_dist=1000;
  463.   for(st=0;st<STARNO;st++)
  464.     if(distance(st,sta)<=b_dist && ore_need(pla,st)>ore_send(pla,st))
  465.     {
  466.     b_sta=st;
  467.     b_dist=distance(st,sta);
  468.     }
  469.   return(b_sta);
  470.   }
  471.