/*  R I S K -             PC versie   */
/*  Henk Overtoom, 1993   TurboC      */
/*                                    */
/**************************************/

#include <stdio.h>
#include <graphics.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include <io.h>

#define NA 49
#define ZA 4
#define EU 7
#define AF 6
#define AZ 39
#define AU 4
#define UNO 109

char *naam[]={
/*   0 */  "blanco",
/*   1 */  "Alaska     ",
/*   2 */  "Br.Columbia",
/*   3 */  "Alberta",
/*   4 */  "Saskatchwan",
/*   5 */  "Manitoba",
/*   6 */  "Ontario",
/*   7 */  "Quebec",
/*   8 */  "Groenland",
/*   9 */  "Washington",
/*  10 */  "Idaho",
/*  11 */  "Montana",
/*  12 */  "Nth. Dakota",
/*  13 */  "Minnesota",
/*  14 */  "Wisconsin",
/*  15 */  "Michigan",
/*  16 */  "New York",
/*  17 */  "Maine",
/*  18 */  "Oregon",
/*  19 */  "Wyoming",
/*  20 */  "Sth. Dakota",
/*  21 */  "California",
/*  22 */  "Nevada",
/*  23 */  "Utah",
/*  24 */  "Colorado",
/*  25 */  "Nebraska",
/*  26 */  "Iowa",
/*  27 */  "Illinois",
/*  28 */  "Indiana",
/*  29 */  "Ohio",
/*  30 */  "Pennsylvan.",
/*  31 */  "Kansas",
/*  32 */  "Missouri",
/*  33 */  "Kentucky",
/*  34 */  "W. Virginia",
/*  35 */  "Virginia",
/*  36 */  "Arizona",
/*  37 */  "New Mexico",
/*  38 */  "Oklahoma",
/*  39 */  "Arkansas",
/*  40 */  "Tennessee",
/*  41 */  "N. Carolina",
/*  42 */  "Texas",
/*  43 */  "Louisiana",
/*  44 */  "Missisippi",
/*  45 */  "Alabama",
/*  46 */  "Georgia",
/*  47 */  "S. Carolina",
/*  48 */  "Florida",
/*  49 */  "Midden Am.",   // was nr 9 !
/*  50 */  "Venezuela",
/*  51 */  "Peru",
/*  52 */  "Brazilie",
/*  53 */  "Argentinie",
/*  54 */  "IJsland",
/*  55 */  "N-Europa",
/*  56 */  "Gr. Britt.",
/*  57 */  "WM-Europa",
/*  58 */  "O-Europa",
/*  59 */  "ZW-Europa",
/*  60 */  "ZO-Europa",
/*  61 */  "N-Afrika",
/*  62 */  "Egypte",
/*  63 */  "C-Afrika",
/*  64 */  "O-Afrika",
/*  65 */  "Z-Afrika",
/*  66 */  "Madagaskar",
/*  67 */  "Estland",
/*  68 */  "Wit-Rusland",
/*  69 */  "Oekraine",
/*  70 */  "Turkije",
/*  71 */  "Mid-Oosten",
/*  72 */  "Arabie",
/*  73 */  "Nrd-Rusland",
/*  74 */  "Rusland",
/*  75 */  "Oezbekistan",
/*  76 */  "Iran",
/*  77 */  "Oeral",
/*  78 */  "Ost-Rusland",
/*  79 */  "Kazakstan",
/*  80 */  "Zw-Siberie",
/*  81 */  "Afganistan",
/*  82 */  "Pakistan",
/*  83 */  "Nw-Siberie",
/*  84 */  "Wm-Siberie",
/*  85 */  "Zm-Siberie",
/*  86 */  "West-China",
/*  87 */  "Tibet",
/*  88 */  "Nepal",
/*  89 */  "Indie",
/*  90 */  "Nm-Siberie",
/*  91 */  "Mid-Siberie",
/*  92 */  "Mongolie",
/*  93 */  "Centr-Cina",
/*  94 */  "Zuid-China",
/*  95 */  "Burma",
/*  96 */  "No-Siberie",
/*  97 */  "Ost-Siberie",
/*  98 */  "Oost-China",
/*  99 */  "ZO-China",
/* 100 */  "Vietnam",
/* 101 */  "Thailand",
/* 102 */  "Mantsjoerye",
/* 103 */  "Korea",
/* 104 */  "Kamsjatka",
/* 105 */  "Japan",
/* 106 */  "Indonesie",
/* 107 */  "Nw Guinea",
/* 108 */  "W-Australie",
/* 109 */  "O-Australie"
  };

int l[][9]={
/*   0 */  0,0,0,0,0,0,0,0,0,
/*   1 */  0,0,0,0,104,2,0,0,0,
/*   2 */  0,0,0,0,1,3,9,10,0,
/*   3 */  0,0,0,0,2,4,0,0,11,
/*   4 */  0,0,0,0,3,5,11,0,12,
/*   5 */  0,0,0,0,4,6,12,13,0,
/*   6 */  0,0,0,0,5,7,13,14,15,
/*   7 */  0,0,0,0,6,8,15,16,17,
/*   8 */  0,0,0,0,7,54,0,0,0,
/*   9 */  0,0,0,2,0,0,0,18,10,
/*  10 */  0,9,2,0,0,0,22,0,23,  // 0,9,2,11,0,19,22,0,23,
/*  11 */  0,3,0,4,0,12,0,19,20,  // 0,3,0,4,0,12,10,19,20,
/*  12 */  0,4,0,5,11,0,0,20,13,
/*  13 */  0,12,5,6,20,14,0,26,0,
/*  14 */  0,0,6,0,13,15,26,27,0,
/*  15 */  0,6,0,7,14,0,27,28,29,
/*  16 */  0,0,7,0,0,17,0,30,0,
/*  17 */  0,7,0,0,16,0,0,0,0,
/*  18 */  0,0,9,0,0,0,0,21,22,
/*  19 */  0,0,11,20,0,0,0,0,25,  // 0,0,11,20,10,0,23,24,25,
/*  20 */  0,11,12,0,0,13,19,25,26,
/*  21 */  0,0,18,0,0,22,0,0,36,
/*  22 */  0,18,0,10,21,23,0,36,0,
/*  23 */  0,10,0,0,22,24,36,0,0,  // 0,10,0,19,22,24,36,0,0,
/*  24 */  0,0,0,0,23,0,0,37,38,  // 0,0,19,25,23,31,0,37,38,
/*  25 */  0,19,20,0,0,26,0,31,0,  // 0,19,20,0,0,26,24,31,0,
/*  26 */  0,20,13,14,25,27,0,32,0,
/*  27 */  0,0,14,15,26,28,32,0,0,
/*  28 */  0,0,15,0,27,29,0,0,0,   // 0,0,15,0,27,29,0,0,33,
/*  29 */  0,15,0,0,28,30,0,0,34,  // 0,15,0,0,28,30,0,33,34,
/*  30 */  0,0,16,0,29,0,34,35,0,
/*  31 */  0,0,25,0,0,32,0,38,0,  // 0,0,25,0,24,32,0,38,0,
/*  32 */  0,0,26,27,31,33,38,39,40,
/*  33 */  0,0,0,34,32,0,0,40,0,  // 0,28,29,34,32,35,0,40,0,
/*  34 */  0,29,0,30,0,0,33,0,35,
/*  35 */  0,34,30,0,0,0,0,41,0,  // 0,34,30,0,33,0,40,41,0,
/*  36 */  0,21,22,23,0,37,0,0,49,
/*  37 */  0,0,24,0,36,38,0,49,42,
/*  38 */  0,24,31,32,37,39,0,42,0,
/*  39 */  0,0,32,0,38,40,42,43,44,
/*  40 */  0,32,33,0,39,0,44,45,46,  // 0,32,33,35,39,41,44,45,46,
/*  41 */  0,0,35,0,0,0,46,47,0,  // 0,0,35,0,40,0,46,47,0,
/*  42 */  0,37,38,39,0,43,49,0,0,
/*  43 */  0,0,39,0,42,44,0,0,0,
/*  44 */  0,39,0,40,43,45,0,0,0,
/*  45 */  0,0,40,0,44,46,0,0,48,
/*  46 */  0,40,0,41,45,47,0,48,0,
/*  47 */  0,0,41,0,46,0,0,0,0,
/*  48 */  0,45,46,0,0,0,0,0,0,
/*  49 */  0,36,37,42,0,0,0,50,0,
/*  50 */  0,0,9,0,0,0,11,0,12,
/*  51 */  0,0,0,10,0,12,0,0,13,
/*  52 */  0,10,0,21,11,0,13,0,0,
/*  53 */  0,11,0,12,0,0,0,0,0,
/*  54 */  0,0,0,0,3,15,0,0,16,
/*  55 */  0,0,0,0,14,0,16,17,18,
/*  56 */  0,14,0,15,0,17,0,19,0,
/*  57 */  0,0,15,0,16,18,19,0,20,
/*  58 */  0,15,0,27,17,28,20,0,29,
/*  59 */  0,0,16,17,0,20,0,21,0,
/*  60 */  0,17,0,18,19,29,0,22,30,
/*  61 */  0,0,19,0,0,22,12,23,24,
/*  62 */  0,0,20,31,21,0,0,24,0,
/*  63 */  0,0,21,24,0,0,0,0,25,
/*  64 */  0,21,22,0,0,0,23,25,26,
/*  65 */  0,23,24,26,0,0,0,0,0,
/*  66 */  0,24,0,0,0,0,25,0,0,
/*  67 */  0,0,0,0,0,33,18,28,0,
/*  68 */  0,0,27,0,18,34,0,29,0,
/*  69 */  0,18,28,0,20,39,30,0,35,
/*  70 */  0,20,0,29,0,35,0,31,36,
/*  71 */  0,0,30,0,0,36,22,0,32,
/*  72 */  0,31,0,36,0,0,0,0,0,
/*  73 */  0,0,0,0,27,37,0,34,0,
/*  74 */  0,0,33,0,28,0,0,0,39,
/*  75 */  0,29,0,39,30,40,0,36,41,
/*  76 */  0,30,35,0,31,41,32,0,42,
/*  77 */  0,0,0,0,33,43,0,38,0,
/*  78 */  0,0,37,0,0,44,0,39,0,
/*  79 */  0,34,38,0,29,45,35,40,0,
/*  80 */  0,0,39,45,35,46,0,41,0,
/*  81 */  0,35,40,46,36,0,0,42,47,
/*  82 */  0,36,41,47,0,0,0,0,49,
/*  83 */  0,0,0,0,37,50,0,44,0,
/*  84 */  0,0,43,0,38,51,0,45,0,
/*  85 */  0,0,44,0,39,52,40,46,0,
/*  86 */  0,0,45,52,40,53,41,47,0,
/*  87 */  0,41,46,53,0,54,42,48,0,
/*  88 */  0,0,47,0,0,55,0,49,0,
/*  89 */  0,42,48,55,0,0,0,0,0,
/*  90 */  0,0,0,0,43,56,0,51,0,
/*  91 */  0,0,50,0,44,57,0,52,0,
/*  92 */  0,0,51,0,45,62,46,53,58,
/*  93 */  0,0,52,0,46,58,47,54,0,
/*  94 */  0,0,53,0,47,59,0,55,0,
/*  95 */  0,0,54,0,48,60,49,0,61,
/*  96 */  0,0,0,0,50,0,0,0,57,
/*  97 */  0,56,0,0,51,64,0,58,62,
/*  98 */  0,52,57,62,53,0,0,59,63,
/*  99 */  0,0,58,0,54,0,0,60,0,
/* 100 */  0,0,59,0,55,0,61,0,0,
/* 101 */  0,55,0,60,0,0,0,0,66,
/* 102 */  0,57,0,64,52,0,58,63,0,
/* 103 */  0,58,62,0,0,65,0,0,0,
/* 104 */  0,0,0,0,57,1,62,65,0,
/* 105 */  0,0,64,0,63,0,0,0,0,
/* 106 */  0,61,0,0,0,67,0,68,0,
/* 107 */  0,0,0,0,66,0,68,0,69,
/* 108 */  0,0,66,67,0,69,0,0,0,
/* 109 */  0,67,0,0,68,0,0,0,0
  };

int k[10]={0,6,7,8,4,0,5,1,2,3};
char sps,ps[UNO+1],ls[17],prt[80];
int swd[8],wd[7],tel[10],sor[UNO+1],nl[UNO+1];
int dn[10],ttot[10],comp[10],tcap[10];
int wis1,wis2,sp,ns,node,taktiek=0;
int gdriver=EGA,gmode=EGAHI;

void init(void);
void init1 (void);
void zoek (void);
void picture (void);
void vak (int blk, int xs, int ys);
void save (void);
void aanwas (void);
void telnul (void);
void wdeel (int a, int b);
void move (int c);
void transp (void);
void dices (int dn, int dm);
void attack (void);
void map (void);
void stand (void);
void comput (void);
void cattack (int lmin, int x);
void bel(void);
void cls(void);
void blok (int x1, int y1, int x2, int y2, int mode);
int get(void);
void hlyn (int x1,int x2,int y,int mode);
void vlyn (int y1,int y2,int x,int mode);
void lyn (int x1,int y1,int x2,int y2,int mode);
void txt (int x,int y,char *p);
void port0(void);

main ()
{  int i,j,c;
   char cs;

	initgraph (&gdriver,&gmode,""); setcolor(7);
/*
   printf ("\n\n welke taktiek (0 of 1) ? ");
   taktiek=getk()-48;
*/
    swd[1]=1;
	swd[2]=swd[1]+NA; swd[3]=swd[2]+ZA; swd[4]=swd[3]+EU;
	swd[5]=swd[4]+AF; swd[6]=swd[5]+AZ; swd[7]=swd[6]+AU;
    if (swd[7]!=UNO+1) { printf("/n    Totaal # landen fout !"); exit(0); }
    for (i=50; i<=109; i++) for (j=1; j<=8; j++) if (l[i][j]) l[i][j]+=40;
    l[104][5]=1; l[54][4]=8;

   printf ("\n\n  laden (j/n) : ");
   if (ja()) { c=load();
			   if (c==1) { printf ("\n\n file is er niet !!");
						   getk(); init();  }
			 }
   else init ();

   for (;;)
	  {
	  init1 ();
	  aanwas ();
	  for (sp=1 ; sp<=ns ; sp++)
		 {
		 wis2=0; sps=sp+48;
		 node=0;
		 zoek ();
		 if (dn[sp])
			{
			if (comp[sp])
			   {
			   comput ();
			   }
			else
			   {
			   do
				  {
				  picture ();
						txt (1,23,"./a/d/j/m/t ");
						cs=getk (); c= (cs<'1' || cs>'9') ? 0 : cs-48;
				  switch (cs)
				   {
				   case 't' : transp (); break;
				   case 'j' : zoek ()  ; break;
				   case 'a' : if (!wis2) attack (); break;
				   case 'm' : map (); break;
				   case 's' : stand (); break;
				   case 'S' : save ();
							  setbkcolor(0); closegraph(); restorecrtmode();
							  exit (0);
				   }
				  if (c) move (c);
				  }
			   while (cs!='d');
			   }
			}
		 }
	  }
}

void init ()
{  int i,j,r1,r2,x;
   char cs;

	cls ();
	randomize();

   wis1=1;
   for (i=1 ; i<=9  ; i++) dn[i]=1;
   for (i=1 ; i<=UNO ; i++) nl[i]=8+rand()/8000;

   printf ("\n\n hoeveel spelers ? ");
   ns=getk()-48;

   for (i=1 ; i<=UNO ; i++) sor[i]=i;
   for (i=1 ; i<=200 ; i++)
	  {
	  r1=1+random(UNO); r2=1+random(UNO);
	  x=sor[r1];
	  sor[r1]=sor[r2];
	  sor[r2]=x;
	  }
   for (i=1 ; i<=UNO ; i++) ps[sor[i]]=49+i%ns;

   printf ("\n\n geef aan welke spelers door de atari worden gespeeld");
	printf ("\n ( a=atari, z=zelf ) \n ");
   for (i=1 ; i<=ns ; i++)
	  {
	  printf ("\n  speler %d : ",i);
	  cs=getk ();
	  if (cs=='a')
		 {
		 comp[i]=1;
		 printf (" atari speelt");
		 }
	  else
		 {
		 comp[i]=0;
		 printf (" bordspeler");
		 }
	  tcap[i]=5+random(11);
	  }
}

void init1 ()
{  int i;
   wis1=3-wis1;
	for (i=1 ; i<=6 ; i++) ttot[i]=40*tcap[i]/10;
}

void zoek ()
{  int i;
   if (node<UNO)
	  {
	  for (i=node+1 ; i<=UNO ; i++) { if (ps[i]==sps) { node=i; return; } }
	  }
   for (i=1 ; i<=node ; i++) { if (ps[i]==sps) { node=i; return; } }
   dn[sp]=0;
}

void picture ()
{  int blk;

   cls ();

   blk=l[node][1];
   if (blk) { lyn (144,96,168,144,1); vak (blk,1,1); }
   blk=l[node][2];
   if (blk) { lyn (236,96,236,144,1); vak (blk,21,1); }
   blk=l[node][3];
   if (blk) { lyn (328,96,304,144,1); vak (blk,41,1); }
   blk=l[node][4];
   if (blk) { lyn (144,184,168,184,1); vak (blk,1,9); }
   vak (node,21,9);
   blk=l[node][5];
   if (blk) { lyn (304,184,328,184,1); vak (blk,41,9); }
   blk=l[node][6];
   if (blk) { lyn (144,272,168,224,1); vak (blk,1,17); }
   blk=l[node][7];
   if (blk) { lyn (236,224,236,272,1); vak (blk,21,17); }
   blk=l[node][8];
   if (blk) { lyn (304,224,328,272,1); vak (blk,41,17); }
}

void vak (blk,xs,ys) int blk,xs,ys;
{  int x,y;
	if (ps[blk]==sps) setcolor(3); else setcolor(12);
   x=(xs<<3); y=(ys<<4);
	sprintf (prt,"%c %s", ps[blk],naam[blk]); txt (xs+2,ys+1,prt);
	sprintf (prt,"# legers=%5d", nl[blk]); txt (xs+2,ys+3,prt);
   blok (x,y,x+136,y+80,1);
	blok (x+1,y+1,x+135,y+79,1);
	setcolor(7);
}

load ()
{
  int fd,ret;
  char *name;

   name="RSK.DAT"; ret=0;
	if ((fd=open(name,O_RDWR|O_BINARY))>0)
	  {
		read (fd,&ns,2);
		read (fd,ps,UNO+1);
		read (fd,nl,2*UNO+2);
		read (fd,dn,20);
		read (fd,comp,20);
		read (fd,tcap,20);
		close (fd);
	  }
   else ret=1;
	return (ret);
}

void save ()
{
  int fd;
  char *name;

   cls(); printf ("\n\n  Saven (j/n) : ");
   if (!ja()) return;

   name="RSK.DAT";
	if ((fd=_creat(name,0))>=0L)
	  {
		write (fd,&ns,2);
		write (fd,ps,UNO+1);
		write (fd,nl,2*UNO+2);
		write (fd,dn,20);
		write (fd,comp,20);
		write (fd,tcap,20);
		close (fd);
		}
}


int ja ()
{ int c;
   while (!((c=getk())=='j' || c=='J' || c=='n' || c=='N')) ; putchar (c);
   if (c=='j' || c=='J') return (1);
   else                  return (0);
}

int da,dv;

void aanwas ()
{  int i,j,k;

   for (i=1 ; i<=UNO ; i++)
	  {
      for (k=1; k<=6; k++) if (i==swd[k]) telnul ();
//	  if (i==1 || i==10 || i==14 || i==21 || i==27 || i==66) telnul ();
	  j=ps[i]-48; tel[j]++;
	  if (tel[j]==2) { nl[i]++; tel[j]=0; }
	  }
   for (i=1 ; i<=6 ; i++) wd[i]=0;
   taktiek=0;

   for (k=1; k<=6; k++) {
       telnul ();
	   for (i=swd[k]; i<swd[k+1]; i++) tel[ps[i]-48]++; wdeel (k,swd[k+1]-swd[k]);
       }
   for (k=1; k<=6; k++) { if (wd[k]) { for (i=swd[k]; i<swd[k+1]; i+=2) nl[i]++; } }
}

void telnul ()
{  int i;
   for (i=1 ; i<=9 ; i++) tel[i]=0;
}

void wdeel (a,b) int a,b;
{  int i;
   for (i=1 ; i<=ns ; i++)
	  {
	  if (tel[i]==b)
		 {
		 wd[a]=1; if (i==1) taktiek++;
		 if (a==1) ttot[i]+=50*tcap[i]/10;
		 if (a==2) ttot[i]+=10*tcap[i]/10;
		 if (a==3) ttot[i]+=20*tcap[i]/10;
		 if (a==4) ttot[i]+=15*tcap[i]/10;
		 if (a==5) ttot[i]+=30*tcap[i]/10;
		 if (a==6) ttot[i]+=10*tcap[i]/10;
		 }
	  }
}

void move (int c)
{  int x;
   x=l[node][k[c]];
   if (x==0) return;
   if (ps[x]==sps) node=x;
}

void transp ()
{  int c,x,xd,yd,it;
	char ch;
	txt (1,23,"              ");
	txt (1,23,"doel ?                                     ");

	ch=getk (); c= (ch<'1' || ch>'9') ? 0 : ch-48;
   if (c==5 || c==0) return;
   x=l[node][k[c]]; if (ps[x]!=sps) return;
	sprintf (prt,"aantal (max= %d ) ? ", ttot[sp]); txt (8,23,prt);
	ch=getk (); it= (ch<'0' || ch>'9') ? 0 : ch-48;
   if (it>(nl[node]-1) || it>ttot[sp]) return;

   if (c>6 && c<10) yd=4;
   else
      if (c>3 && c<7) yd=12;
      else
         yd=20;
   if (c%3==1) xd=12;
   else
      if (c==2 || c==8) xd=32;
      else
		 xd=52;
   nl[node]-=it; nl[x]+=it; ttot[sp]-=it; wis2=1;
	sprintf (prt,"%5d", nl[x]); txt (xd,yd,"     "); txt (xd,yd,prt);
	sprintf (prt,"%5d", nl[node]); txt (32,12,"     "); txt (32,12,prt);
   transp ();
}

void attack ()
{  int c,x,xd,yd,dn,dm,cnt,win,it;
   char ch;
   extern int da,dv;

   if (nl[node]<2) return;
	txt (1,23,"               ");
	txt (1,23,"doel ?                      ");
	ch=getk (); c= (ch<'1' || ch>'9') ? 0 : ch-48;
   if (c==5 || c==0) return;
   x=l[node][k[c]]; if (x==0 || ps[x]==sps) return;

   cnt=10; win=0;
   if (c>6 && c<10) yd=4;
   else
      if (c>3 && c<7) yd=12;
      else
         yd=20;
   if (c%3==1) xd=12;
   else
      if (c==2 || c==8) xd=32;
      else
         xd=52;
   while (cnt>0 && win==0 && nl[node]>1)
      {
		txt (1,23,"                 ");
		txt (1,23,"mode s/h ?              ");
		ch=getk ();
      if (ch=='h') break;
      dn= (nl[node]<4) ? nl[node]-1 : 3; dm= (nl[x]<3) ? nl[x] : 3;
	  dices (dn,dm);
      nl[node]-=da; nl[x]-=dv;

		sprintf (prt,"%5d", nl[node]); txt (32,12,"     "); txt (32,12,prt);
		sprintf (prt,"%5d", nl[x]); txt (xd,yd,"     "); txt (xd,yd,prt);

      if (nl[x]==0) { win=1; break; }
      cnt--;
      }

   if (win)
      {
		ps[x]=sps;
		sprintf (prt,
		"%s veroverd !! Hoeveel legers vrij verplaatsen ? ", naam[x]);
		it=geti(1,23,prt,2); if (it<1 || it>(nl[node]-1)) it=nl[node]-1;
      nl[x]=it; nl[node]-=it; node=x;
      }
}

void dices (int dn, int dm)
{
 int di,dj,dp,dq,dr,dx,dy,dz;
 extern int da,dv;

   da=0; dv=0; di= (dm<dn) ? dm : dn;
   dp=1+rand()/5462; dq=1+rand()/5462; dr=1+rand()/5462;
   dx=1+rand()/5462; dy=1+rand()/5462; dz=1+rand()/5462;
   da+=di;

   if (dn>2 && dq<dr) { dj=dq; dq=dr; dr=dj; }
   if (dn>1 && dp<dq) { dj=dp; dp=dq; dq=dj; }
   if (dm>2 && dy<dz) { dj=dy; dy=dz; dz=dj; }
   if (dm>1 && dx<dy) { dj=dx; dx=dy; dy=dj; }
   if (dp>dx) { da--; dv++; }
   if (di<2) return;
   if (dq>dy) { da--; dv++; }
   if (di<3) return;
   if (dr<=dz) return;
   da--; dv++;
}

void map ()
{  int i;

   cls ();
	txt (0,0,"Noord Amerika       Afika               Azie");
   for (i=1 ; i<=6 ; i++)
      {
		sprintf (prt,"%c %s", ps[i],naam[i]);       txt (0,i+1,prt);
		sprintf (prt,"%c %s", ps[i+20],naam[i+20]); txt (20,i+1,prt);
		sprintf (prt,"%c %s", ps[i+26],naam[i+26]); txt (40,i+1,prt);
		sprintf (prt,"%c %s", ps[i+46],naam[i+46]); txt (60,i+1,prt);
	  }

	 sprintf (prt,"%c %s", ps[7],naam[7]);   txt (0,8,prt);
	 sprintf (prt,"%c %s", ps[33],naam[33]); txt (40,8,prt);
	 sprintf (prt,"%c %s", ps[53],naam[53]); txt (60,8,prt);

	 sprintf (prt,"%c %s", ps[8],naam[8]);   txt (0,9,prt);
	 sprintf (prt,"Zuid Amerika");           txt (20,9,prt);
	 sprintf (prt,"%c %s", ps[34],naam[34]); txt (40,9,prt);
	 sprintf (prt,"%c %s", ps[54],naam[54]); txt (60,9,prt);

	 sprintf (prt,"%c %s", ps[9],naam[9]);   txt (0,10,prt);
	 sprintf (prt,"%c %s", ps[35],naam[35]); txt (40,10,prt);
	 sprintf (prt,"%c %s", ps[55],naam[55]); txt (60,10,prt);

	 txt (0,13,"Europa");
   for (i=11 ; i<=14 ; i++)
      {
		 sprintf (prt,"%c %s", ps[i-1],naam[i-1]);   txt (20,i,prt);
		 sprintf (prt,"%c %s", ps[i+25],naam[i+25]); txt (40,i,prt);
		 sprintf (prt,"%c %s", ps[i+45],naam[i+45]); txt (60,i,prt);
      }

	 txt (20,16,"Australie");
   for (i=15 ; i<=17 ; i++)
      {
		sprintf (prt,"%c %s", ps[i-1],naam[i-1]);   txt (0,i,prt);
		sprintf (prt,"%c %s", ps[i+25],naam[i+25]); txt (40,i,prt);
		sprintf (prt,"%c %s", ps[i+45],naam[i+45]); txt (60,i,prt);
      }

   for (i=18 ; i<=21 ; i++)
      {
		sprintf (prt,"%c %s", ps[i-1],naam[i-1]);    txt (0,i,prt);
		sprintf (prt,"%c %s", ps[i+48],naam[i+48]);  txt (20,i,prt);
		sprintf (prt,"%c %s", ps[i+25], naam[i+25]); txt (40,i,prt);
      }

   for (i=18 ; i<=20 ; i++)
	  {
		sprintf (prt,"%c %s", ps[i+45], naam[i+45]); txt (60,i,prt);
	  }
	txt (60,23,"doorgaan ? "); getk ();
}

void stand ()
{
 int i,j,la,le,verh;

 	cls();
    printf ("\n  Speler  # Landen  # legers   gem. #\n");
	for (i=1; i<=ns; i++) {
    	la=le=0;
        for (j=1; j<=UNO; j++) {
        	if (i==ps[j]-48) { la++; le+=nl[j]; }
            }
        if (la) verh=le/la; else verh=0;
        printf ("\n\n     %d      %4d       %4d      %d", i,la,le,verh);
        }
    printf ("\n\n\n");
	txt (60,23,"doorgaan ? "); getk ();
}

void comput ()
{  int old,vmax,i,j,x,lmin,ne,som,pot;

   cls (); old=0;
   while (node>old)
	  {
	  if (nl[node]<5) { old=node; zoek (); continue; }
	  vmax=0;
	  for (i=1 ; i<=8 ; i++)
		 {
		 x=l[node][i];
		 if (x!=0 && ps[x]!=sps) vmax= (vmax>nl[x]) ? vmax : nl[x];
		 }
	  if (vmax==0) { old=node; zoek (); continue; }
	  lmin=vmax>>1; if (lmin<5) lmin=5;
	  if (nl[node]<lmin) { old=node; zoek (); continue; }

		for (j=1; j<=ns; j++) {
		  for (i=1 ; i<=8 ; i++)
			 {
			 x=l[node][i];
			 if (x!=0 && ps[x]==j+48 && ps[x]!=sps && nl[node]>=lmin)
				{
				if (j==1 && 100*nl[node]/nl[x]-15*(6-taktiek)>rand()/327) cattack (lmin,x);
				else if (100*nl[node]/nl[x]-10*(9+taktiek)>rand()/327) cattack (lmin,x);
				}
			 }
		  }

	  old=node; zoek ();
	  }

   printf ("\n\n doorgaan ? ");

	old=0;
	while (node>old && ttot[sp]>0)
	  {
	  som=nl[node];ne=1; vmax=0;
	  for (i=1 ; i<=8 ; i++)
		 {
		 x=l[node][i]; if (x==0) continue;
		 if (ps[x]==sps) { ne++; som+=nl[x]; }
		 else vmax= (vmax>nl[x]) ? vmax : nl[x];
		 }
	  if (ne==1) { old=node; zoek (); continue; }
	  if (vmax==0) pot=nl[node]-1;
	  else { pot=nl[node]-som/ne; if (pot<0) pot=0; }
	  pot/=(ne-1); if (pot==0) { old=node; zoek (); continue; }
	  for (i=1 ; i<=8 ; i++)
		 {
		 x=l[node][i];
		 if (x!=0 && ps[x]==sps) nl[x]+=pot;
		 }
		nl[node]-=(ne-1)*pot; ttot[sp]-=(ne-1)*pot;
		if (nl[node]<1) nl[node]=1;
	  old=node; zoek ();
	  }
	getk ();
}

void cattack (int lmin, int x)
{  int i,dn,dm,cnt;

	printf ("\n%c %11s  aangevallen door  %c %11s", ps[x],naam[x],
												 ps[node],naam[node]);
   cnt=10;
   while (--cnt>0 && nl[node]>=lmin && nl[x]>0)

	  {
	  dn=3; dm=(nl[x]<3) ? nl[x] : 3;
	  dices (dn,dm);
	  nl[node]-=da; nl[x]-=dv;
	  }
   if (nl[x]==0)
	  {
	  printf ("  veroverd !!!\n");
	  ps[x]=sps;
	  i=nl[node]>>1; nl[x]=i; nl[node]-=i;
	  }
   else
	  {
	  printf ("  %5d - %5d\n", nl[x], nl[node]);
	  }
}


void pauze () { getk(); }

int get ()
{ int c;
	if (bioskey(1)) { c=bioskey(0); return(c); }
}

getk()
{
 int c;

	c=(char)bioskey(0);
	return (c);
}

void bel()  { printf ("\007"); }

void cls ()
{          cleardevice();
}

void zetcur (int x,int y)
{
char *p="";

	outtextxy (8*x,14*y,p);
}

geti (int x, int y, char *p, int n)
{
 int xx,yy,l;
 int i,c,h;
 char s[6]; char *t=".....";

	if (gdriver==EGA) h=14; else h=96/5;
	xx=8*x; yy=y*h; l=strlen(p)+1;
	setviewport (xx,yy,xx+8*(l+n),yy+h,0); clearviewport();
	outtextxy (0,0,p);

	t[n]=0; outtextxy ((l+1)*8,0,t);

	i=0;
	while ((c=getk())!=13)
	  {
	  if (c==8 || c==127)
		 {
			if (i>0) { i--;
							setviewport ((x+l+i+1)*8,yy,(x+l+i+2)*8,yy+h,1);
							clearviewport(); outtext (".");
							setviewport (xx,yy,xx+8*(l+n),yy+h,0);
							}
		 }
		else
			{
		 if (i<n)
			{
			if (c<48 || c>57) ;
				else { s[i]=c; s[i+1]=0; outtextxy ((l+i+1)*8,0,&s[i]); i++; }
			}
		 }
	  }
	s[i]=0;


	if (i==0) return (-1);
   else return (atoi(s));
}

void blok (int x1, int y1, int x2, int y2, int mode)
{ hlyn (x1,x2,y1,mode) ;
  vlyn (y1,y2,x1,mode) ;
  hlyn (x1,x2,y2,mode) ;
  vlyn (y1,y2,x2,mode) ;
}

void hlyn (int x1,int x2,int y,int mode)
{
lyn (x1,y,x2,y,mode);
}

void vlyn (int y1,int y2,int x,int mode)
{
lyn (x,y1,x,y2,mode);
}

void lyn (int x1,int y1,int x2,int y2,int mode)
{
 int yy1,yy2;

	if (gdriver==EGA) { yy1=y1*7/8; yy2=y2*7/8; }
	else              { yy1=y1*6/5; yy2=y2*6/5; }
	line (x1,yy1,x2,yy2);
}

void txt (int x,int y,char *p)
{
 int xx,yy,l,een;

	xx=8*x; l=strlen(p);
	if (gdriver==EGA) { yy=y*14; een=14; }
	else              { yy=y*96/5; een=96/5; }
	setviewport (xx,yy,xx+8*l,yy+een,0); clearviewport();
	outtextxy (0,0,p); port0();
}

void port0()
{
	if (gdriver==EGA) setviewport (0,0,639,349,1);
	else              setviewport (0,0,639,479,1);
}

void tus (i) int i;
{
	printf ("  test %d", i);
	getk();
}