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     ! 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.