Return to info.c CVS log

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

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

1.1       root        1: #ifndef lint
                      2: static char *sccsid = "@(#)info.c      1.1 83/03/17";
                      3: #endif
                      4: #include "externs.h"
                      5: 
                      6: char *
                      7: speed(n)
                      8: int n;
                      9: {
                     10:     switch(n)
                     11:        {
                     12:        case 1:
                     13:            return("light breeze");
                     14:        case 2:
                     15:            return("moderate breeze");
                     16:        case 3:
                     17:            return("fresh breeze");
                     18:        case 4:
                     19:            return("strong breeze");
                     20:        case 5:
                     21:            return("gale");
                     22:        default:
                     23:            return("radioactive winds");
                     24:        }
                     25: }
                     26: char *
                     27: wind(n)
                     28: int n;
                     29: {
                     30:     switch(scene[n].winddir)
                     31:        {
                     32:        case 1:
                     33:            return("S");
                     34:        case 2:
                     35:            return("SW");
                     36:        case 3:
                     37:            return("W");
                     38:        case 4:
                     39:            return("NW");
                     40:        case 5:
                     41:            return("N");
                     42:        case 6:
                     43:            return("NE");
                     44:        case 7:
                     45:            return("E");
                     46:        case 8:
                     47:            return("SE");
                     48:        default:
                     49:            return("Lost in space");
                     50:        }
                     51: }
                     52: char
                     53: colours(ship)
                     54: int ship;
                     55: {
                     56:     switch(ship)
                     57:        {
                     58:        case 0:
                     59:            return('a');
                     60:        case 1:
                     61:            return('b');
                     62:        case 2:
                     63:            return('s');
                     64:        case 3:
                     65:            return('f');
                     66:        default:
                     67:            return('z');
                     68:        }
                     69: }
                     70: 
                     71: char *quality(game, shipnum)
                     72: int shipnum;
                     73: int game;
                     74: {
                     75:     switch(specs[scene[game].ship[shipnum].shipnum].qual)
                     76:        {
                     77:        case 5:
                     78:            return("elite");
                     79:        case 4:
                     80:            return("crack");
                     81:        case 3:
                     82:            return("average");
                     83:        case 2:
                     84:            return("green");
                     85:        case 1:
                     86:            return("mutinous");
                     87:        default:
                     88:            return("stoned");
                     89:        }
                     90: }
                     91: 
                     92: char *info(game, ship, final)
                     93: int game;
                     94: int ship;
                     95: char *final;
                     96: {
                     97:     sprintf(final, "%d gun \0", specs[scene[game].ship[ship].shipnum].guns);
                     98:     switch(specs[scene[game].ship[ship].shipnum].class)
                     99:        {
                    100:        case 1:
                    101:            strcat(final, "3 Decker SOL");
                    102:            break;
                    103:        case 2:
                    104:            strcat(final, "Ship of the Line");
                    105:            break;
                    106:        case 3:
                    107:            strcat(final, "Frigate");
                    108:            break;
                    109:        case 4:
                    110:            strcat(final, "Corvette");
                    111:            break;
                    112:        case 5:
                    113:            strcat(final, "Sloop");
                    114:            break;
                    115:        case 6:
                    116:            strcat(final, "Brig");
                    117:            break;
                    118:     }
                    119:     return(final);
                    120: }
                    121: 
                    122: main()
                    123: {
                    124:     char buf[80];
                    125:     register int n,j;
                    126: 
                    127:     for (n=0; n < NUMOFSCENES; n++)
                    128:        {
                    129:        printf("\n%s:\n\n\tWind from the %s, blowing a %s.\n\n", scene[n].name, wind(n), speed(scene[n].windspeed));
                    130:        for (j = 0; j < scene[n].vessels; j++)
                    131:            printf("\t(%c) %-18s%s (%s crew) (%d pts)\n", colours(scene[n].ship[j].nationality), scene[n].ship[j].shipname, info(n, j, buf), quality(n, j), specs[scene[n].ship[j].shipnum].pts);
                    132:        }
                    133: }

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