![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to back.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / games|
Return to back.c CVS log | Up to [Research Unix] / researchv10no / games |
1.1 root 1: # include <stdio.h>
2:
3: #
4: #define NIL (-1)
5: #define MAXGMOV 10
6: #define MAXIMOVES 1000
7: char level; /*'b'=beginner, 'i'=intermediate, 'e'=expert*/
8: int die1;
9: int die2;
10: int i;
11: int j;
12: int l;
13: int m;
14: int count;
15: int red[] = {0,2,0,0,0,0,0,0,0,0,0,0,5,
16: 0,0,0,0,3,0,5,0,0,0,0,0,
17: 0,0,0,0,0,0};
18: int white[] = {0,2,0,0,0,0,0,0,0,0,0,0,5,
19: 0,0,0,0,3,0,5,0,0,0,0,0,
20: 0,0,0,0,0,0};
21: int probability[]={0,11,12,13,14,15,16,
22: 06,05,04,03,02,01};
23: int imoves;
24: int goodmoves[MAXGMOV] ;
25: int probmoves[MAXGMOV] ;
26: struct {int pos[4],mov[4];} moves[MAXIMOVES] ;
27:
28: main()
29: {
30: int t,k,n,go[5];
31: char s[100];
32: go[5]=NIL;
33: /* this allows only 30,000 different patterns of dice throws */
34: srand( getpid() );
35: printf( "Do you want instructions? Type 'y' for yes,\n");
36: printf( "anything else means no.?? ");
37: getstr(s);
38: if(*s=='y')instructions();
39: printf( "Choose the level of your oppponent.\n");
40: printf( "Type 'b' for beginner, or 'i' for intermediate.\n");
41: printf( "Anything else gets you an expert.?? ");
42: level='e';
43: getstr(s);
44: if(*s=='b')level='b';
45: else if(*s=='i')level='i';
46: printf( "You will play red. Do you wan't to move first?\n");
47: printf( "Type 'y' for yes, anything else means no.?? ");
48: getstr(s);
49: if(*s=='y')goto nowhmove;
50: whitesmv:
51: roll();
52: printf( "white rolls %d,%d\n",die1,die2);
53: printf( "white's move is:");
54: if(nextmove(white,red)==NIL)goto nowhmove;
55: if(piececount(white,0,24)==0){
56: printf( "White wins\n");
57: printf( "Aren't you ashamed. You've been beaten by a computer.\n");
58: exit();
59: }
60: nowhmove:
61: prtbrd();
62:
63: roll();
64: retry:
65: printf( "your roll is %d, %d\n",die1,die2);
66: printf( "your move, please?? ");
67: getstr(s);
68: if(*s==0){
69: printf( "red's move skipped\n");
70: goto whitesmv;
71: }
72: n=sscanf(s,"%d%d%d%d%d",&go[0],&go[1],&go[2],&go[3],&go[4]);
73: if((die1!=die2&&n>2)||n>4){
74: printf( "you've made too many moves\n");
75: goto retry;
76: }
77: go[n]=NIL;
78: if(*s=='-'){
79: go[0]= -go[0];
80: t=die1;
81: die1=die2;
82: die2=t;
83: }
84: for(k=0;k<n;k++){
85: if(0<=go[k] && go[k]<=24)continue;
86: else{
87: printf( "move %d is illegal\n",go[k]);
88: goto retry;
89: }
90: }
91: if(play(red,white,go))goto retry;
92: if(piececount(red,0,24)==0){
93: printf( "Red wins.\n");
94: printf( "Congratulations! You have just defeated a dumb machine.\n");
95: exit();
96: }
97: goto whitesmv;
98: }
99:
100: getstr(s)
101: char *s;
102: {
103: while((*s=getchar())!='\n')s++;
104: *s=0;
105: }
106:
107: play(player,playee,pos)
108: int *player,*playee,pos[];
109: {
110: int k,n,die,ipos;
111: for(k=0;k<player[0];k++){ /*blots on player[0] must be moved first*/
112: if(pos[k]==NIL)break;
113: if(pos[k]!=0){
114: printf( "piece on position 0 must be moved first\n");
115: return(-1);
116: }
117: }
118: for(k=0;(ipos=pos[k])!=NIL;k++){
119: die=k?die2:die1;
120: n=25-ipos-die;
121: if(player[ipos]==0)goto badmove;
122: if(n>0&&playee[n]>=2)goto badmove;
123: if(n<=0){
124: if(piececount(player,0,18)!=0)goto badmove;
125: if((ipos+die)!=25&&
126: piececount(player,19,24-die)!=0)goto badmove;
127: }
128: player[ipos]--;
129: player[ipos+die]++;
130: }
131: for(k=0;pos[k]!=NIL;k++){
132: die=k?die2:die1;
133: n=25-pos[k]-die;
134: if(n>0 && playee[n]==1){
135: playee[n]=0;
136: playee[0]++;
137: }
138: }
139: return(0);
140:
141: badmove:
142: printf( "Move %d is not legal.\n",ipos);
143: while(k--){
144: die=k?die2:die1;
145: player[pos[k]]++;
146: player[pos[k]+die]--;
147: }
148: return(-1);
149: }
150: nextmove(player,playee)
151: int *player,*playee;
152: {
153: int k;
154: imoves=0;
155: movegen(player,playee);
156: if(die1!=die2){
157: k=die1;
158: die1=die2;
159: die2=k;
160: movegen(player,playee);
161: }
162: if(imoves==0){
163: printf( "roll was %d,%d; no white move possible\n",die1,die2);
164: return(NIL);
165: }
166: k=strategy(player,playee); /*select kth possible move*/
167: prtmov(k);
168: update(player,playee,k);
169: return(0);
170: }
171: prtmov(k)
172: int k;
173: {
174: int n;
175: if(k==NIL)printf( "no move possible\n");
176: else for(n=0;n<4;n++){
177: if(moves[k].pos[n]==NIL)break;
178: printf( " %d, %d",25-moves[k].pos[n],moves[k].mov[n]);
179: }
180: printf( "\n");
181: }
182: update(player,playee,k)
183: int *player,*playee,k;
184: {
185: int n,t;
186: for(n=0;n<4;n++){
187: if(moves[k].pos[n]==NIL)break;
188: player[moves[k].pos[n]]--;
189: player[moves[k].pos[n]+moves[k].mov[n]]++;
190: t=25-moves[k].pos[n]-moves[k].mov[n];
191: if(t>0 && playee[t]==1){
192: playee[0]++;
193: playee[t]--;
194: }
195: }
196: }
197: piececount(player,startrow,endrow)
198: int *player,startrow,endrow;
199: {
200: int sum;
201: sum=0;
202: while(startrow<=endrow)
203: sum+=player[startrow++];
204: return(sum);
205: }
206: /*
207: prtmovs()
208: {
209: int i1,i2;
210: printf( "possible moves are\n");
211: for(i1=0;i1<imoves;i1++){
212: printf( "\n%d",i1);
213: for(i2=0;i2<4;i2++){
214: if(moves[i1].pos[i2]==NIL)break;
215: printf( "%d, %d",moves[i1].pos[i2],moves[i1].mov[i2]);
216: }
217: }
218: printf( "\n");
219: }
220: */
221:
222: roll()
223: {
224: extern int die1,die2;
225: die1=(rand()>>8)%6+1;
226: die2=(rand()>>8)%6+1;
227: }
228:
229: movegen(mover,movee)
230: int *mover,*movee;
231: {
232: extern int i,j,l,m,count;
233: extern int die1,die2;
234: int k;
235: for(i=0;i<=24;i++){
236: count=0;
237: if(mover[i]==0)continue;
238: if((k=25-i-die1)>0&&movee[k]>=2)
239: if(mover[0]>0)break;
240: else continue;
241: if(k<=0){
242: if(piececount(mover,0,18)!=0)break;
243: if((i+die1)!=25&&
244: piececount(mover,19,24-die1)!=0)break;
245: }
246: mover[i]--;
247: mover[i+die1]++;
248: count=1;
249: for(j=0;j<=24;j++){
250: if(mover[j]==0)continue;
251: if((k=25-j-die2)>0&&movee[k]>=2)
252: if(mover[0]>0)break;
253: else continue;
254: if(k<=0){
255: if(piececount(mover,0,18)!=0)break;
256: if((j+die2)!=25&&
257: piececount(mover,19,24-die2)!=0)break;
258: }
259: mover[j]--;
260: mover[j+die2]++;
261: count=2;
262: if(die1!=die2){
263: moverecord(mover);
264: if(mover[0]>0)break;
265: else continue;
266: }
267: for(l=0;l<=24;l++){
268: if(mover[l]==0)continue;
269: if((k=25-l-die1)>0&&movee[k]>=2)
270: if(mover[0]>0)break;
271: else continue;
272: if(k<=0){
273: if(piececount(mover,0,18)!=0)break;
274: if((l+die2)!=25&&
275: piececount(mover,19,24-die1)!=0)break;
276: }
277: mover[l]--;
278: mover[l+die1]++;
279: count=3;
280: for(m=0;m<=24;m++){
281: if(mover[m]==0)continue;
282: if((k=25-m-die1)>=0&&movee[k]>=2)
283: if(mover[0]>0)break;
284: else continue;
285: if(k<=0){
286: if(piececount(mover,0,18)!=0)break;
287: if((m+die2)!=25&&
288: piececount(mover,19,24-die1)!=0)break;
289: }
290: count=4;
291: moverecord(mover);
292: if(mover[0]>0)break;
293: }
294: if(count==3)moverecord(mover);
295: else{
296: mover[l]++;
297: mover[l+die1]--;
298: }
299: if(mover[0]>0)break;
300: }
301: if(count==2)moverecord(mover);
302: else{
303: mover[j]++;
304: mover[j+die1]--;
305: }
306: if(mover[0]>0)break;
307: }
308: if(count==1)moverecord(mover);
309: else{
310: mover[i]++;
311: mover[i+die1]--;
312: }
313: if(mover[0]>0)break;
314: }
315: }
316: moverecord(mover)
317: int *mover;
318: {
319: extern int i,j,l,m,imoves,count;
320: int t;
321: if(imoves>=MAXIMOVES)goto undo;;
322: for(t=0;t<=3;t++)
323: moves[imoves].pos[t]= NIL;
324: switch(count){
325: case 4:
326: moves[imoves].pos[3]=m;
327: moves[imoves].mov[3]=die1;
328: case 3:
329: moves[imoves].pos[2]=l;
330: moves[imoves].mov[2]=die1;
331: case 2:
332: moves[imoves].pos[1]=j;
333: moves[imoves].mov[1]=die2;
334: case 1:
335: moves[imoves].pos[0]=i;
336: moves[imoves].mov[0]=die1;
337: imoves++;
338: }
339: undo:
340: switch(count){
341: case 4:
342: break;
343: case 3:
344: mover[l]++;
345: mover[l+die1]--;
346: break;
347: case 2:
348: mover[j]++;
349: mover[j+die2]--;
350: break;
351: case 1:
352: mover[i]++;
353: mover[i+die1]--;
354: }
355: }
356:
357:
358: strategy(player,playee)
359: int *player,*playee;
360: {
361: extern char level;
362: int k,n,nn,bestval,moveval,prob;
363: n=0;
364: if(imoves==0)return(NIL);
365: goodmoves[0]=NIL;
366: bestval= -32000;
367: for(k=0;k<imoves;k++){
368: if((moveval=eval(player,playee,k,&prob))<bestval)continue;
369: if(moveval>bestval){
370: bestval=moveval;
371: n=0;
372: }
373: if(n<MAXGMOV){
374: goodmoves[n]=k;
375: probmoves[n++]=prob;
376: }
377: }
378: if(level=='e' && n>1){
379: nn=n;
380: n=0;
381: prob=32000;
382: for(k=0;k<nn;k++){
383: if((moveval=probmoves[k])>prob)continue;
384: if(moveval<prob){
385: prob=moveval;
386: n=0;
387: }
388: goodmoves[n]=goodmoves[k];
389: probmoves[n++]=probmoves[k];
390: }
391: }
392: return(goodmoves[(rand()>>4)%n]);
393: }
394:
395: eval(player,playee,k,prob)
396: int *player,*playee,k,*prob;
397: {
398: extern char level;
399: int newtry[31],newother[31],*r,*q,*p,n,sum,first;
400: int ii,lastwhite,lastred;
401: *prob=sum=0;
402: r=player+25;
403: p=newtry;
404: q=newother;
405: while(player<r){
406: *p++= *player++;
407: *q++= *playee++;
408: }
409: q=newtry+31;
410: for(p=newtry+25;p<q;) *p++ = 0; /*zero out spaces for hit pieces*/
411: for(n=0;n<4;n++){
412: if(moves[k].pos[n]==NIL)break;
413: newtry[moves[k].pos[n]]--;
414: newtry[ii=moves[k].pos[n]+moves[k].mov[n]]++;
415: if(ii<25 && newother[25-ii]==1){
416: newother[25-ii]=0;
417: newother[0]++;
418: if(ii<=15 && level=='e')sum++; /*hit if near other's home*/
419: }
420: }
421: for(lastred=0;newother[lastred]==0;lastred++);
422: for(lastwhite=0;newtry[lastwhite]==0;lastwhite++);
423: lastwhite=25-lastwhite;
424: if(lastwhite<=6 && lastwhite<lastred)sum=1000;
425: if(lastwhite<lastred && level=='e'
426: && lastwhite>6){ /*expert's running game.
427: First priority to get all
428: pieces into white's home*/
429: for(sum=1000;lastwhite>6;lastwhite--)
430: sum=sum-lastwhite*newtry[25-lastwhite];
431: }
432: for(first=0;first<25;first++)
433: if(newother[first]!=0)break; /*find other's first piece*/
434: q=newtry+25;
435: for(p=newtry+1;p<q;)if(*p++ > 1)sum++; /*blocked points are good*/
436: if(first>5){ /*only stress removing pieces if homeboard
437: cannot be hit
438: */
439: q=newtry+31;
440: p=newtry+25;
441: for(n=6;p<q;n--)
442: sum+= *p++ * n; /*remove pieces, but just barely*/
443: }
444: if(level!='b'){
445: r=newtry+25-first; /*singles past this point can't be hit*/
446: for(p=newtry+7;p<r;)
447: if(*p++ == 1)sum--; /*singles are bad after 1st 6 points
448: if they can be hit*/
449: q=newtry+3;
450: for(p=newtry;p<q;)sum=- *p++; /*bad to be on 1st three points*/
451: }
452:
453: for(n=1;n<=4;n++)
454: *prob+= n*getprob(newtry,newother,6*n-5,6*n);
455: return(sum);
456: }
457: instructions()
458: {
459: printf( "To play backgammon, type the numbers of the points\n");
460: printf( "from which pieces are to be moved. Thus, if the\n");
461: printf( "roll is '3,5', typing '2 6' will move a piece\n");
462: printf( "from point 2 three spaces to point 5,\n");
463: printf( "and a piece from point 6 forward to\n");
464: printf( "point 11. If the moves must be made in the\n");
465: printf( "opposite order, the first character typed must\n");
466: printf( "be a minus ('-'). Thus, typing\n");
467: printf( "'-2 6' moves the piece on point 2\n");
468: printf( "by 5, and the piece on point 6 by 3.\n");
469: printf( "If you want to move a single piece several times,\n");
470: printf( "the sequence of points from which it is to be\n");
471: printf( "moved must be typed. Thus '14 17' will move\n");
472: printf( "a piece from point 14 to point 17 and thence to\n");
473: printf( "to point 22.\n");
474: printf( "If a double is rolled, you should type four numbers.\n");
475: printf( "Red pieces that have been removed from the board by\n");
476: printf( "being hit by white are on point 0 and\n");
477: printf( "must be brought in before any other move can be made.\n");
478: printf( "White pieces that are hit are removed to point 25.\n");
479: printf( "You will not be allowed to make an illegal move, or\n");
480: printf( "to make too many moves. However, if you make too\n");
481: printf( "few moves, the program does not care. In particular\n");
482: printf( "you may skip your turn by typing a 'new-line'\n");
483: printf( "all by itself.\n\n");
484: }
485:
486: getprob(player,playee,start,finish)
487: int *player,*playee,start,finish;
488: { /*returns the probability (times 102) that any
489: pieces belonging to 'player' and lying between
490: his points 'start' and 'finish' will be hit
491: by a piece belonging to playee
492: */
493: int k,n,sum;
494: sum=0;
495: for(;start<=finish;start++){
496: if(player[start]==1){
497: for(k=1;k<=12;k++){
498: if((n=25-start-k)<0)break;
499: if(playee[n]!=0)sum+=probability[k];
500: }
501: }
502: }
503: return(sum);
504: }
505: prtbrd()
506: {
507: int k;
508: printf( "White's Home\n");
509: for(k=1;k<=6;k++)
510: printf( "%4d",k);
511: printf( " ");
512: for(k=7;k<=12;k++)printf( "%4d",k);
513: putchar('\n' );
514: for(k=1;k<=54;k++)putchar('-' );
515: putchar('\n' );
516: numline(red,white,1,6);
517: printf( " ");
518: numline(red,white,7,12);
519: putchar('\n' );
520: colorline(red,'R',white,'W',1,6);
521: printf( " ");
522: colorline(red,'R',white,'W',7,12);
523: putchar('\n' );
524: if(white[0]!=0)printf( "%28dW\n",white[0]);
525: else putchar('\n' );
526: if(red[0]!=0)printf( "%28dR\n",red[0]);
527: else putchar('\n' );
528: colorline(white,'W',red,'R',1,6);
529: printf( " ");
530: colorline(white,'W',red,'R',7,12);
531: putchar('\n' );
532: numline(white,red,1,6);
533: printf( " ");
534: numline(white,red,7,12);
535: putchar('\n' );
536: for(k=1;k<=54;k++)putchar('-' );
537: putchar('\n' );
538: for(k=24;k>=19;k--)printf( "%4d",k);
539: printf( " ");
540: for(k=18;k>=13;k--)printf( "%4d",k);
541: printf( "\nRed's Home\n\n\n\n\n");
542: }
543: numline(upcol,downcol,start,fin)
544: int *upcol,*downcol,start,fin;
545: {
546: int k,n;
547: for(k=start;k<=fin;k++){
548: if((n=upcol[k])!=0 || (n=downcol[25-k])!=0)printf( "%4d",n);
549: else printf( " ");
550: }
551: }
552: colorline(upcol,c1,downcol,c2,start,fin)
553: int *upcol,*downcol,start,fin;
554: char c1,c2;
555: {
556: int k;
557: char c;
558: for(k=start;k<=fin;k++){
559: c=' ';
560: if(upcol[k]!=0)c=c1;
561: if(downcol[25-k]!=0)c=c2;
562: printf( " %c",c);
563: }
564: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.