Return to life.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / cmd

Annotation of researchv9/jtools/src/cmd/life.c, revision 1.1

1.1     ! root        1: #include "jerq.h"
        !             2: #include <stdio.h>
        !             3: #include <ctype.h>
        !             4: 
        !             5: unsigned short delta[] = {
        !             6:        0x0001, 0x0100, 0x0101, 0x00ff, 0xff00, 0xffff, 0xff01, 0xfeff
        !             7: };
        !             8: 
        !             9: char   magic[] = {
        !            10:        0, 0, 0, 1, 0, 0, 0, 0,
        !            11:        0, 0, 1, 1, 0, 0, 0, 0
        !            12: };
        !            13: 
        !            14: char   *setment[] = {
        !            15:        "run",
        !            16:        "clear",
        !            17:        "read file",
        !            18:        "write file",
        !            19:        "exit",
        !            20:        0
        !            21: };
        !            22: 
        !            23: Menu   setmen = { setment };
        !            24: 
        !            25: char   *runment[] = {
        !            26:        "setup",
        !            27:        "stop",
        !            28:        "slow",
        !            29:        "exit",
        !            30:        0
        !            31: };
        !            32: 
        !            33: Menu   runmen = { runment };
        !            34: 
        !            35: unsigned long  *hash;
        !            36: unsigned short list[512];
        !            37: unsigned short *lend;
        !            38: unsigned short olist[512];
        !            39: unsigned short *olend;
        !            40: unsigned long  *hlist[768];
        !            41: unsigned long  **hlistp;
        !            42: Bitmap *discmap;
        !            43: Bitmap *circmap;
        !            44: Point  setpt();
        !            45: unsigned short getpt();
        !            46: int    stopmode;
        !            47: int    slowmode;
        !            48: int    stepcount;
        !            49: FILE   *filep;
        !            50: 
        !            51: main(argc, argv)
        !            52: char *argv[];
        !            53: {
        !            54:        register i;
        !            55:        register unsigned short *lp;
        !            56: 
        !            57: #ifdef JERQ
        !            58:        request(KBD|MOUSE|RCV);
        !            59: #else
        !            60:        request(KBD|MOUSE);
        !            61: #endif
        !            62:        initdisplay(argc, argv);
        !            63:        olend = olist;
        !            64:        if ((discmap = balloc(Rect(0, 0, 16, 16))) == (Bitmap *)NULL)
        !            65:                exit();
        !            66:        if ((circmap = balloc(Rect(0, 0, 16, 16))) == (Bitmap *)NULL)
        !            67:                exit();
        !            68:        rectf(discmap, discmap->rect, F_CLR);
        !            69:        disc(discmap, Pt(7, 7), 7, F_XOR);
        !            70:        rectf(circmap, circmap->rect, F_CLR);
        !            71:        circle(circmap, Pt(7, 7), 2, F_XOR);
        !            72:        if ((hash = (unsigned long *)gcalloc(sizeof(long)*8192L,
        !            73:           (char **)&hash)) == (unsigned long *)NULL)
        !            74:                exit();
        !            75:        setup();
        !            76:        while (kbdchar() != 'q') {
        !            77:                if (own()&MOUSE && button1())
        !            78:                        stepcount = 1;
        !            79:                if (own()&MOUSE && button2()) {
        !            80:                        switch(menuhit(&runmen, 2)) {
        !            81:                        case 0:                 /* setup */
        !            82:                                setup();
        !            83:                                continue;
        !            84:                        case 1:                 /* stop/go */
        !            85:                                runment[1] = stopmode? "stop":"go";
        !            86:                                stopmode ^= 01;
        !            87:                                break;
        !            88: 
        !            89:                        case 2:                 /* fast/slow */
        !            90:                                runment[2] = slowmode? "slow":"fast";
        !            91:                                slowmode ^= 01;
        !            92:                                break;
        !            93: 
        !            94:                        case 3:                 /* exit */
        !            95:                                exit(0);
        !            96:                        }
        !            97:                }
        !            98:                if (stopmode && stepcount == 0) {
        !            99:                        wait(MOUSE);
        !           100:                        continue;
        !           101:                }
        !           102:                if (stepcount > 0)
        !           103:                        stepcount--;
        !           104:                if (slowmode)
        !           105:                        sleep(30);
        !           106:                gendisplay();
        !           107:                genhash();
        !           108:                genlist();
        !           109:                wait(CPU);
        !           110:        }
        !           111: }
        !           112: 
        !           113: genhash()
        !           114: {
        !           115:        register unsigned short *lp;
        !           116:        register unsigned long *hp, vl;
        !           117:        register short unsigned i, v, vn;
        !           118: 
        !           119:        hlistp = hlist;
        !           120:        for (lp = list; lp < lend; ) {
        !           121:                v = *lp++;
        !           122:                hp = &hash[v>>3];
        !           123:                if (*hp == 0)
        !           124:                        *hlistp++ = hp;
        !           125:                *hp |= 0x8L << ((v&07) << 2);
        !           126:                for (i=0; i<8; i++) {
        !           127:                        vn = v + delta[i];
        !           128:                        hp = &hash[vn>>3];
        !           129:                        if (*hp == 0)
        !           130:                                *hlistp++ = hp;
        !           131:                        vl = 0x4L << ((vn&07) << 2);
        !           132:                        if ((*hp & vl) == 0) {
        !           133:                                vl >>= 2;
        !           134:                                *hp += vl;
        !           135:                        }
        !           136:                }
        !           137:        }
        !           138:        *hlistp = 0;
        !           139: }
        !           140: 
        !           141: genlist()
        !           142: {
        !           143:        register unsigned long h;
        !           144:        register i, j;
        !           145:        register unsigned short *lp;
        !           146:        register unsigned long *hp;
        !           147: 
        !           148:        lp = lend = list;
        !           149:        hlistp = hlist;
        !           150:        while (hp = *hlistp++) {
        !           151:                h = *hp;
        !           152:                i = hp - hash;
        !           153:                for (j = 0; h != 0; j++) {
        !           154:                        if (magic[h&0xf] /* && not at side edge */ )
        !           155:                                *lp++ = (i<<3) + j;
        !           156:                        h >>= 4;
        !           157:                }
        !           158:                *hp = 0;
        !           159:        }
        !           160:        lend = lp;
        !           161: }
        !           162: 
        !           163: gendisplay()
        !           164: {
        !           165:        register x, y;
        !           166:        register unsigned short *lp;
        !           167:        Point orig;
        !           168:        static short black_bits[]={
        !           169:                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
        !           170:                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
        !           171:        };
        !           172:        static Texture black;
        !           173:        static int first = 1;
        !           174: 
        !           175:        if (first) {
        !           176:                first = 0;
        !           177:                black = ToTexture(black_bits);
        !           178:        }
        !           179:        rectf(&display, display.rect, F_STORE);
        !           180:        orig = div(add(Drect.origin, Drect.corner), 2);
        !           181:        for (lp = list; lp < lend; ) {
        !           182:                x = ((*lp >> 8) - 0x80) << 2;
        !           183:                y = ((*lp++ & 0xff) - 0x80) << 2;
        !           184:                texture(&display, Rpt(add(orig, Pt(x,y)),
        !           185:                            add(orig, Pt(x+2,y+2))), &black, F_XOR);
        !           186:        }
        !           187: }
        !           188: 
        !           189: setup()
        !           190: {
        !           191:        register i, j;
        !           192:        register unsigned short *lp;
        !           193: 
        !           194:        for (i = 0; i < 8192; i++)
        !           195:                hash[i] = 0;
        !           196:        cleanset();
        !           197:     more:
        !           198:        while(button1() && wait(MOUSE))
        !           199:                ;
        !           200:        for (;; wait(MOUSE)) {
        !           201:                if (button1()) {
        !           202:                        unsigned short p;
        !           203:                        p = getpt();
        !           204:                        for (lp = olist; lp < olend; lp++) {
        !           205:                                if (*lp == p) {
        !           206:                                        while (lp < olend-1) {
        !           207:                                                *lp = *(lp+1);
        !           208:                                                lp++;
        !           209:                                        }
        !           210:                                        dispt(circmap, p);
        !           211:                                        olend--;
        !           212:                                        goto more;
        !           213:                                }
        !           214:                        }
        !           215:                        *olend++ = p;
        !           216:                        dispt(discmap, p);
        !           217:                        goto more;
        !           218:                }
        !           219:                if (button2()) {
        !           220:                        switch(menuhit(&setmen, 2)) {
        !           221: 
        !           222:                        case 0: /* run */
        !           223:                                break;
        !           224: 
        !           225:                        case 1: /* clear */
        !           226:                                olend = olist;
        !           227:                                cleanset();
        !           228:                                goto more;
        !           229: 
        !           230:                        case 2: /* read file */
        !           231:                                if (getfile('r') == 0)
        !           232:                                        goto more;
        !           233:                                olend = olist;
        !           234:                                cleanset();
        !           235:                                for (;;) {
        !           236:                                        int x, y;
        !           237:                                        if (getnum(&x)==0)
        !           238:                                                break;
        !           239:                                        if (getnum(&y)==0)
        !           240:                                                break;
        !           241:                                        x += 0x80;
        !           242:                                        y += 0x80;
        !           243:                                        *olend = (x<<8) | (y & 0xff);
        !           244:                                        dispt(discmap, *olend++);
        !           245:                                }
        !           246:                                fclose(filep);
        !           247:                                goto more;
        !           248: 
        !           249:                        case 3: /* write file */
        !           250:                                if (getfile('w') == 0)
        !           251:                                        goto more;
        !           252:                                for (lp = olist; lp < olend; lp++) {
        !           253:                                        putnum((*lp>>8)-0x80);
        !           254:                                        putc(' ', filep);
        !           255:                                        putnum((*lp&0xFF)-0x80);
        !           256:                                        putc('\n', filep);
        !           257:                                }
        !           258:                                putc('X', filep);
        !           259:                                fclose(filep);
        !           260:                                goto more;
        !           261: 
        !           262:                        case 4: /* exit */
        !           263:                                exit(0);
        !           264: 
        !           265:                        default:
        !           266:                                continue;
        !           267:                        }
        !           268:                        break;
        !           269:                }
        !           270:        }
        !           271:        for (lp = olist, lend = list; lp < olend; )
        !           272:                *lend++ = *lp++;
        !           273: }
        !           274: 
        !           275: Point
        !           276: setpt(p)
        !           277: unsigned short p;
        !           278: {
        !           279:        Point pt;
        !           280:        register x, y;
        !           281: 
        !           282:        pt = add(Drect.origin,mul(div(sub(Drect.corner,Drect.origin),32),16));
        !           283:        x = ((p>>8) - 0x80) << 4;
        !           284:        y = ((p & 0xff) - 0x80) << 4;
        !           285:        return(add(pt, Pt(x,y)));
        !           286: }
        !           287: 
        !           288: dispt(map, p)
        !           289: register struct Bitmap *map;
        !           290: unsigned short p;
        !           291: {
        !           292:        trimblt(map, map->rect, setpt(p), F_STORE);
        !           293: }
        !           294: 
        !           295: unsigned short
        !           296: getpt()
        !           297: {
        !           298:        register Point sp, o;
        !           299: 
        !           300:        sp = div(sub(mouse.xy, Drect.origin), 16);
        !           301:        o = div(sub(Drect.corner,Drect.origin),32);
        !           302:        sp = sub(sp, o);
        !           303:        return(((0x80+sp.x)<<8) + ((0x80+sp.y) & 0xff));
        !           304: }
        !           305: 
        !           306: cleanset()
        !           307: {
        !           308:        register unsigned short *lp;
        !           309:        register i, j;
        !           310: 
        !           311:        for (i=Drect.origin.x; i < Drect.corner.x; i += 16)
        !           312:                trimblt(circmap, circmap->rect,
        !           313:                     Pt(i, Drect.origin.y), F_STORE);
        !           314:        for (j=Drect.origin.y+16; j < Drect.corner.y; j += 16)
        !           315:                trimblt(&display,
        !           316:                    Rpt(Drect.origin, Pt(Drect.corner.x, Drect.origin.y+16)),
        !           317:                    Pt(Drect.origin.x, j), F_STORE);
        !           318:        for (lp = olist; lp <olend; lp++)
        !           319:                dispt(discmap, *lp);
        !           320: }
        !           321: 
        !           322: getnum(np)
        !           323: register int *np;
        !           324: {
        !           325:        register n=0, c, got=0, neg=0;
        !           326: 
        !           327:        for (;;) {
        !           328:                c = getc(filep);
        !           329:                if (c==' ' || c=='\t' || c=='\n') {
        !           330:                        if (got) {
        !           331:                                if (neg)
        !           332:                                        n = -n;
        !           333:                                *np = n;
        !           334:                                return(1);
        !           335:                        }
        !           336:                } else if (c>='0' && c<='9') {
        !           337:                        n = n*10 + c - '0';
        !           338:                        got = 1;
        !           339:                } else if (c=='-')
        !           340:                        neg = 1;
        !           341:                else {
        !           342:                        if (c != 'X') {
        !           343:                                rectf(&display, Drect, F_CLR);
        !           344:                                string(&defont, "Not a life file", &display,
        !           345:                                    add(display.rect.origin, Pt(20,20)), F_XOR);
        !           346:                                sleep(120);
        !           347:                                cleanset();
        !           348:                        }
        !           349:                        return(0);
        !           350:                }
        !           351:        }
        !           352: }
        !           353: 
        !           354: getfile(rw)
        !           355: {
        !           356:        char file[128];
        !           357:        register char *fp = file;
        !           358:        register c;
        !           359:        Point fs;
        !           360:        int strw = strwidth(&defont, "x");
        !           361: 
        !           362:        fp = file;
        !           363:     redraw:
        !           364:        while (kbdchar() >= 0)
        !           365:                ;
        !           366:        rectf(&display, Drect, F_CLR);
        !           367:        fs = string(&defont, "File: ", &display,
        !           368:                 add(display.rect.origin, Pt(20,20)), F_XOR);
        !           369:        for (;;) {
        !           370:                wait(KBD);
        !           371:                c = kbdchar();
        !           372:                switch(c) {
        !           373: 
        !           374:                case -1:
        !           375:                        return(0);
        !           376: 
        !           377:                case '\n':
        !           378:                case '\r':
        !           379:                        break;
        !           380: 
        !           381:                case '\b':
        !           382:                        if (fp > file) {
        !           383:                                *fp = '\0';
        !           384:                                fp--;
        !           385:                                string(&defont, fp, &display,
        !           386:                                  sub(fs, Pt(strw, 0)), F_XOR);
        !           387:                                fs = sub(fs, Pt(strw, 0));
        !           388:                        }
        !           389:                        continue;
        !           390: 
        !           391:                case '@':
        !           392:                        fp = file;
        !           393:                        goto redraw;
        !           394: 
        !           395:                default:
        !           396:                        *fp = c;
        !           397:                        fp[1] = '\0';
        !           398:                        fs = string(&defont, fp++, &display, fs, F_XOR);
        !           399:                        continue;
        !           400:                }
        !           401:                break;
        !           402:        }
        !           403:        *fp++ = '\0';
        !           404:        if ((filep = fopen(file, rw == 'r' ? "r" : "w")) != NULL) {
        !           405:                cleanset();
        !           406:                return(1);
        !           407:        }
        !           408:        rectf(&display, Drect, F_CLR);
        !           409:        fs = string(&defont, "Can't open it.", &display,
        !           410:                add(display.rect.origin, Pt(20,20)), F_XOR);
        !           411:        sleep(120);
        !           412:        cleanset();
        !           413:        return(0);
        !           414: }
        !           415: 
        !           416: putnum(x)
        !           417: register x;
        !           418: {
        !           419:        register t;
        !           420: 
        !           421:        if (x < 0) {
        !           422:                putc('-', filep);
        !           423:                x = -x;
        !           424:        }
        !           425:        if ((t = x/10) > 0)
        !           426:                putnum(t);
        !           427:        putc(x%10 + '0', filep);
        !           428: }
        !           429: 
        !           430: trimblt(sb, r, p, f)
        !           431: Bitmap *sb;
        !           432: Rectangle r;
        !           433: Point p;
        !           434: Code f;
        !           435: {
        !           436:        Rectangle nr;
        !           437:        int v;
        !           438:        
        !           439:        nr = raddp(r, sub(p, r.origin));
        !           440:        v = rectclip(&nr, Drect);
        !           441:        if (v) {
        !           442:                nr = rsubp(nr, sub(p, r.origin));
        !           443:                bitblt(sb, nr, &display, p, f);
        !           444:        }
        !           445: }

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