Return to main.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / sail

Annotation of 42BSD/games/sail/main.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char *sccsid = "@(#)main.c      1.1 83/03/17";
                      3: #endif
                      4: #include "externs.h"
                      5: 
                      6: #define distance(x,y) (abs(x) >= abs(y) ? abs(x) + abs(y)/2 : abs(y) + abs(x)/2)
                      7: 
                      8: range(fromship, toship)
                      9: register int fromship, toship;
                     10: {
                     11:     int bow1r, bow1c, bow2r, bow2c;
                     12:     int stern1r, stern1c, stern2c, stern2r;
                     13:     register int bb, bs, sb, ss, result;
                     14: 
                     15:     if (fromship > scene[game].vessels
                     16:            || toship > scene[game].vessels) /* just in case */
                     17:        return(30000);
                     18:     if (!pos[toship].dir)
                     19:        return(30000);
                     20:     stern1r = bow1r = pos[fromship].row;
                     21:     stern1c = bow1c = pos[fromship].col;
                     22:     stern2r = bow2r = pos[toship].row;
                     23:     stern2c = bow2c = pos[toship].col;
                     24:     result = bb = distance((bow2r - bow1r), (bow2c - bow1c));
                     25:     if (bb < 5)
                     26:        {
                     27:        drdc(&stern2r, &stern2c, pos[toship].dir);
                     28:        drdc(&stern1r, &stern1c, pos[fromship].dir);
                     29:        bs = distance((bow2r - stern1r) ,(bow2c - stern1c));
                     30:        sb = distance((bow1r - stern2r) ,(bow1c - stern2c));
                     31:        ss = distance((stern2r - stern1r) ,(stern2c - stern1c));
                     32:        result = min(bb, min(bs, min(sb, ss)));
                     33:        }
                     34:     return(result);
                     35: }
                     36: 
                     37: drdc(dr, dc, dir)
                     38: register int *dr, *dc;
                     39: int dir;
                     40: {
                     41:     switch (dir)
                     42:        {
                     43:        case 1:
                     44:            (*dr)++;
                     45:            break;
                     46:        case 2:
                     47:            (*dr)++;
                     48:            (*dc)--;
                     49:            break;
                     50:        case 3:
                     51:            (*dc)--;
                     52:            break;
                     53:        case 4:
                     54:            (*dr)--;
                     55:            (*dc)--;
                     56:            break;
                     57:        case 5:
                     58:            (*dr)--;
                     59:            break;
                     60:        case 6:
                     61:            (*dr)--;
                     62:            (*dc)++;
                     63:            break;
                     64:        case 7:
                     65:            (*dc)++;
                     66:            break;
                     67:        case 8:
                     68:            (*dr)++;
                     69:            (*dc)++;
                     70:            break;
                     71:        }
                     72: }

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