Return to selunit.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / learn

Annotation of 43BSDTahoe/usr.bin/learn/selunit.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)selunit.c  4.4     (Berkeley)      9/11/87";
                      3: #endif not lint
                      4: 
                      5: #include "stdio.h"
                      6: #include "lrnref.h"
                      7: 
                      8: int    nsave   = 0;
                      9: int    review  = 0;
                     10: 
                     11: selunit()
                     12: {
                     13:        static char dobuff[50];
                     14:        static char saved[20];
                     15:        char fnam[80], s[80], zb[200];
                     16:        char posslev[20][20];
                     17:        int diff[20], i, k, m, n, best, alts;
                     18:        char *getlesson();
                     19:        FILE *f;
                     20: 
                     21:        if (again) {
                     22:                again = 0;
                     23:                if (todo=getlesson()) {
                     24:                        if (!review)
                     25:                                unsetdid(todo);
                     26:                        return;
                     27:                }
                     28:                wrapup(1);
                     29:        }
                     30:        while (ask) {
                     31:                printf("What lesson? ");
                     32:                fflush(stdout);
                     33:                if (gets(dobuff) == NULL)
                     34:                        wrapup(1);
                     35:                if (strcmp(dobuff, "bye") == 0)
                     36:                        wrapup(1);
                     37:                level = dobuff;
                     38:                if (todo=getlesson())
                     39:                        return;
                     40:        }
                     41:        alts = 0;
                     42: retry:
                     43:        f = scrin;                      /* use old lesson to find next */
                     44:        if (f==NULL) {
                     45:                sprintf(fnam, "%s/%s/L%s", direct, sname, level);
                     46:                f = fopen(fnam, "r");
                     47:                if (f==NULL) {
                     48:                        perror(fnam);
                     49:                        fprintf(stderr, "Selunit:  no script for lesson %s.\n", level);
                     50:                        wrapup(1);
                     51:                }
                     52:                while (fgets(zb, 200, f)) {
                     53:                        trim(zb);
                     54:                        if (strcmp(zb, "#next")==0)
                     55:                                break;
                     56:                }
                     57:        }
                     58:        if (feof(f)) {
                     59:                printf("Congratulations; you have finished this sequence.\n");
                     60:                fflush(stdout);
                     61:                todo = 0;
                     62:                wrapup(-1);
                     63:        }
                     64:        for(i=0; fgets(s, 80, f); i++) {
                     65:                sscanf(s, "%s %d", posslev[i], &diff[i]);
                     66:        }
                     67:        best = -1;
                     68:        /* cycle through lessons from random start */
                     69:        /* first try the current place, failing that back up to
                     70:             last place there are untried alternatives (but only one backup) */
                     71:        n = grand()%i;
                     72:        for(k=0; k<i; k++) {
                     73:                m = (n+k)%i;
                     74:                if (already(posslev[m]))
                     75:                        continue;
                     76:                if (best<0)
                     77:                        best = m;
                     78:                alts++;                         /* real alternatives */
                     79:                if (abs(diff[m]-speed) < abs(diff[best]-speed))
                     80:                        best = m;
                     81:        }
                     82:        if (best < 0 && nsave) {
                     83:                nsave--;
                     84:                strcpy(level, saved);
                     85:                goto retry;
                     86:        }
                     87:        if (best < 0) {
                     88:                /* lessons exhausted or missing */
                     89:                printf("Sorry, there are no alternative lessons at this stage.\n");
                     90:                printf("See someone for help.\n");
                     91:                fflush(stdout);
                     92:                todo = 0;
                     93:                return;
                     94:        }
                     95:        strcpy (dobuff, posslev[best]);
                     96:        if (alts>1) {
                     97:                nsave = 1;
                     98:                strcpy(saved, level);
                     99:        }
                    100:        todo = dobuff;
                    101:        fclose(f);
                    102: }
                    103: 
                    104: abs(x)
                    105: {
                    106:        return(x>=0 ? x : -x);
                    107: }
                    108: 
                    109: grand()
                    110: {
                    111:        static int garbage;
                    112:        int a[2], b;
                    113: 
                    114:        time(a);
                    115:        b = a[1]+10*garbage++;
                    116:        return(b&077777);
                    117: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.