Return to s_gen.c CVS log

Up to [Micropolis - Activity] / micropolis / src / sim

Annotation of micropolis/src/sim/s_gen.c, revision 1.1

1.1     ! root        1: /* s_gen.c
        !             2:  *
        !             3:  * Micropolis, Unix Version.  This game was released for the Unix platform
        !             4:  * in or about 1990 and has been modified for inclusion in the One Laptop
        !             5:  * Per Child program.  Copyright (C) 1989 - 2007 Electronic Arts Inc.  If
        !             6:  * you need assistance with this program, you may contact:
        !             7:  *   http://wiki.laptop.org/go/Micropolis  or email  [email protected].
        !             8:  * 
        !             9:  * This program is free software: you can redistribute it and/or modify
        !            10:  * it under the terms of the GNU General Public License as published by
        !            11:  * the Free Software Foundation, either version 3 of the License, or (at
        !            12:  * your option) any later version.
        !            13:  * 
        !            14:  * This program is distributed in the hope that it will be useful, but
        !            15:  * WITHOUT ANY WARRANTY; without even the implied warranty of
        !            16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            17:  * General Public License for more details.  You should have received a
        !            18:  * copy of the GNU General Public License along with this program.  If
        !            19:  * not, see <http://www.gnu.org/licenses/>.
        !            20:  * 
        !            21:  *             ADDITIONAL TERMS per GNU GPL Section 7
        !            22:  * 
        !            23:  * No trademark or publicity rights are granted.  This license does NOT
        !            24:  * give you any right, title or interest in the trademark SimCity or any
        !            25:  * other Electronic Arts trademark.  You may not distribute any
        !            26:  * modification of this program using the trademark SimCity or claim any
        !            27:  * affliation or association with Electronic Arts Inc. or its employees.
        !            28:  * 
        !            29:  * Any propagation or conveyance of this program must include this
        !            30:  * copyright notice and these terms.
        !            31:  * 
        !            32:  * If you convey this program (or any modifications of it) and assume
        !            33:  * contractual liability for the program to recipients of it, you agree
        !            34:  * to indemnify Electronic Arts for any liability that those contractual
        !            35:  * assumptions impose on Electronic Arts.
        !            36:  * 
        !            37:  * You may not misrepresent the origins of this program; modified
        !            38:  * versions of the program must be marked as such and not identified as
        !            39:  * the original program.
        !            40:  * 
        !            41:  * This disclaimer supplements the one included in the General Public
        !            42:  * License.  TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
        !            43:  * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
        !            44:  * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK.  THE ENTIRE RISK OF
        !            45:  * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU.  ELECTRONIC ARTS
        !            46:  * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
        !            47:  * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
        !            48:  * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
        !            49:  * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
        !            50:  * USAGE, OR TRADE PRACTICE.  ELECTRONIC ARTS DOES NOT WARRANT AGAINST
        !            51:  * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
        !            52:  * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
        !            53:  * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
        !            54:  * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
        !            55:  * CORRECTED.  NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
        !            56:  * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY.  SOME
        !            57:  * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
        !            58:  * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
        !            59:  * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
        !            60:  * NOT APPLY TO YOU.
        !            61:  */
        !            62: #include "sim.h"
        !            63: 
        !            64: 
        !            65: /* Generate Map */
        !            66: 
        !            67: 
        !            68: #define WATER_LOW      RIVER /* 2 */
        !            69: #define WATER_HIGH     LASTRIVEDGE /* 20 */
        !            70: #define WOODS_LOW      TREEBASE /* 21 */
        !            71: #define WOODS_HIGH     UNUSED_TRASH2 /* 39 */
        !            72: 
        !            73: 
        !            74: short XStart, YStart, MapX, MapY;
        !            75: short Dir, LastDir;
        !            76: int TreeLevel = -1;            /* level for tree creation */
        !            77: int LakeLevel = -1;            /* level for lake creation */
        !            78: int CurveLevel = -1;           /* level for river curviness */
        !            79: int CreateIsland = -1;         /* -1 => 10%, 0 => never, 1 => always */
        !            80: 
        !            81: 
        !            82: GenerateNewCity(void) 
        !            83: {
        !            84:   GenerateSomeCity(Rand16());
        !            85: }
        !            86: 
        !            87: 
        !            88: GenerateSomeCity(int r)
        !            89: {
        !            90:   if (CityFileName != NULL) {
        !            91:     ckfree(CityFileName);
        !            92:     CityFileName = NULL;
        !            93:   }
        !            94: 
        !            95:   gettimeofday(&start_time, NULL);
        !            96: 
        !            97:   GenerateMap(r);
        !            98:   ScenarioID = 0;
        !            99:   CityTime = 0;
        !           100:   InitSimLoad = 2;
        !           101:   DoInitialEval = 0;
        !           102: 
        !           103:   InitWillStuff();
        !           104:   ResetMapState();
        !           105:   ResetEditorState();
        !           106:   InvalidateEditors();
        !           107:   InvalidateMaps();
        !           108:   UpdateFunds();
        !           109:   DoSimInit();
        !           110:   Eval("UIDidGenerateNewCity");
        !           111:   Kick();
        !           112: }
        !           113: 
        !           114: 
        !           115: ERand(short limit)
        !           116: {
        !           117:   short x, z;
        !           118: 
        !           119:   z = Rand(limit);
        !           120:   x = Rand(limit);
        !           121:   if (z < x)
        !           122:     return (z);
        !           123:   return (x);
        !           124: }
        !           125: 
        !           126: 
        !           127: GenerateMap(int r)
        !           128: {
        !           129:   SeedRand(r);
        !           130: 
        !           131:   if (CreateIsland < 0) {
        !           132:     if (Rand(100) < 10) { /* chance that island is generated */
        !           133:       MakeIsland();
        !           134:       return;
        !           135:     }
        !           136:   }
        !           137:   if (CreateIsland == 1) {
        !           138:     MakeNakedIsland();
        !           139:   } else {
        !           140:     ClearMap();
        !           141:   }
        !           142:   GetRandStart();
        !           143:   if (CurveLevel != 0) {
        !           144:     DoRivers();
        !           145:   }
        !           146:   if (LakeLevel != 0) {
        !           147:     MakeLakes();
        !           148:   }
        !           149:   SmoothRiver();
        !           150:   if (TreeLevel != 0) {
        !           151:     DoTrees();
        !           152:   }
        !           153:   RandomlySeedRand();
        !           154: }
        !           155: 
        !           156: 
        !           157: ClearMap(void)
        !           158: {
        !           159:   register short x, y;
        !           160: 
        !           161:   for (x = 0; x < WORLD_X; x++)
        !           162:     for (y = 0; y < WORLD_Y; y++)
        !           163:       Map[x][y] = DIRT;
        !           164: }
        !           165: 
        !           166: 
        !           167: ClearUnnatural(void)
        !           168: {
        !           169:   register short x, y;
        !           170: 
        !           171:   for (x = 0; x < WORLD_X; x++) {
        !           172:     for (y = 0; y < WORLD_Y; y++) {
        !           173:       if (Map[x][y] > WOODS) {
        !           174:        Map[x][y] = DIRT;
        !           175:       }
        !           176:     }
        !           177:   }
        !           178: }
        !           179: 
        !           180: 
        !           181: #define RADIUS 18
        !           182: 
        !           183: MakeNakedIsland()
        !           184: {
        !           185:   register int x, y;
        !           186: 
        !           187:   for (x = 0; x < WORLD_X; x++)
        !           188:     for (y = 0; y < WORLD_Y; y++)
        !           189:       Map[x][y] = RIVER;
        !           190:   for (x = 5; x < WORLD_X - 5; x++)
        !           191:     for (y = 5; y < WORLD_Y - 5; y++)
        !           192:       Map[x][y] = DIRT;
        !           193:   for (x = 0; x < WORLD_X - 5; x += 2) {
        !           194:     MapX = x ;
        !           195:     MapY = ERand(RADIUS);
        !           196:     BRivPlop();
        !           197:     MapY = (WORLD_Y - 10) - ERand(RADIUS);
        !           198:     BRivPlop();
        !           199:     MapY = 0;
        !           200:     SRivPlop();
        !           201:     MapY = (WORLD_Y - 6);
        !           202:     SRivPlop();
        !           203:   }
        !           204:   for (y = 0; y < WORLD_Y - 5; y += 2) {
        !           205:     MapY = y ;
        !           206:     MapX = ERand(RADIUS);
        !           207:     BRivPlop();
        !           208:     MapX = (WORLD_X - 10) - ERand(RADIUS);
        !           209:     BRivPlop();
        !           210:     MapX = 0;
        !           211:     SRivPlop();
        !           212:     MapX = (WORLD_X - 6);
        !           213:     SRivPlop();
        !           214:   }
        !           215: }
        !           216: 
        !           217: 
        !           218: MakeIsland(void)
        !           219: {
        !           220:   MakeNakedIsland();
        !           221:   SmoothRiver();
        !           222:   DoTrees();
        !           223: }
        !           224: 
        !           225: 
        !           226: MakeLakes(void)
        !           227: {
        !           228:   short Lim1, Lim2, t, z;
        !           229:   register short x, y;
        !           230: 
        !           231:   if (LakeLevel < 0) {
        !           232:     Lim1 = Rand(10);
        !           233:   } else {
        !           234:     Lim1 = LakeLevel / 2;
        !           235:   }
        !           236:   for (t = 0; t < Lim1; t++) {
        !           237:     x = Rand(WORLD_X - 21) + 10;
        !           238:     y = Rand(WORLD_Y - 20) + 10;
        !           239:     Lim2 = Rand(12) + 2;
        !           240:     for (z = 0; z < Lim2; z++) {
        !           241:       MapX = x - 6 + Rand(12);
        !           242:       MapY = y - 6 + Rand(12);
        !           243:       if (Rand(4))
        !           244:        SRivPlop();
        !           245:       else
        !           246:        BRivPlop();
        !           247:     }
        !           248:   }
        !           249: }
        !           250: 
        !           251: 
        !           252: GetRandStart(void)
        !           253: {
        !           254:   XStart = 40 + Rand(WORLD_X - 80);
        !           255:   YStart = 33 + Rand(WORLD_Y - 67);
        !           256:   MapX = XStart;
        !           257:   MapY = YStart;
        !           258: }
        !           259: 
        !           260: 
        !           261: MoveMap(short dir)
        !           262: {
        !           263:   static short DirTab[2][8] = { { 0, 1, 1, 1, 0, -1, -1, -1},
        !           264:                                {-1,-1, 0, 1, 1,  1,  0, -1} };
        !           265:   dir = dir & 7;
        !           266:   MapX += DirTab[0][dir];
        !           267:   MapY += DirTab[1][dir];
        !           268: }
        !           269: 
        !           270: 
        !           271: TreeSplash(short xloc, short yloc)
        !           272: {
        !           273:   short dis, dir;
        !           274:   register short xoff, yoff, z;
        !           275: 
        !           276:   if (TreeLevel < 0) {
        !           277:     dis = Rand(150) + 50;
        !           278:   } else {
        !           279:     dis = Rand(100 + (TreeLevel * 2)) + 50;
        !           280:   }
        !           281:   MapX = xloc;
        !           282:   MapY = yloc;
        !           283:   for (z = 0; z < dis; z++) {
        !           284:     dir = Rand(7);
        !           285:     MoveMap(dir);
        !           286:     if (!(TestBounds(MapX, MapY)))
        !           287:       return;
        !           288:     if ((Map[MapX][MapY] & LOMASK) == DIRT)
        !           289:       Map[MapX][MapY] = WOODS + BLBNBIT;
        !           290:   }
        !           291: }
        !           292: 
        !           293: 
        !           294: DoTrees(void)
        !           295: {
        !           296:   short Amount, x, xloc, yloc;
        !           297: 
        !           298:   if (TreeLevel < 0) {
        !           299:     Amount = Rand(100) + 50;
        !           300:   } else {
        !           301:     Amount = TreeLevel + 3;
        !           302:   }
        !           303:   for(x = 0; x < Amount; x++) {
        !           304:     xloc = Rand(WORLD_X - 1);
        !           305:     yloc = Rand(WORLD_Y - 1);
        !           306:     TreeSplash(xloc, yloc);
        !           307:   }
        !           308:   SmoothTrees();
        !           309:   SmoothTrees();
        !           310: }
        !           311: 
        !           312: 
        !           313: SmoothRiver(void)
        !           314: {
        !           315:   static short DX[4] = {-1, 0, 1, 0};
        !           316:   static short DY[4] = { 0, 1, 0,-1};
        !           317:   static short REdTab[16] = {
        !           318:     13+BULLBIT,        13+BULLBIT,     17+BULLBIT,     15+BULLBIT,
        !           319:     5+BULLBIT, 2,              19+BULLBIT,     17+BULLBIT,
        !           320:     9+BULLBIT, 11+BULLBIT,     2,              13+BULLBIT,
        !           321:     7+BULLBIT, 9+BULLBIT,      5+BULLBIT,      2 };
        !           322:   short bitindex, z, Xtem, Ytem;
        !           323:   register short temp, MapX, MapY;
        !           324: 
        !           325:   for (MapX = 0; MapX < WORLD_X; MapX++) {
        !           326:     for (MapY = 0; MapY < WORLD_Y; MapY++) {
        !           327:       if (Map[MapX][MapY] == REDGE) {
        !           328:        bitindex = 0;
        !           329:        for (z = 0; z < 4; z++) {
        !           330:          bitindex = bitindex << 1;
        !           331:          Xtem = MapX + DX[z];
        !           332:          Ytem = MapY + DY[z];
        !           333:          if (TestBounds(Xtem, Ytem) &&
        !           334:              ((Map[Xtem][Ytem] & LOMASK) != DIRT) &&
        !           335:              (((Map[Xtem][Ytem]&LOMASK) < WOODS_LOW) ||
        !           336:               ((Map[Xtem][Ytem]&LOMASK) > WOODS_HIGH)))
        !           337:              bitindex++;
        !           338:        }
        !           339:        temp = REdTab[bitindex & 15];
        !           340:        if ((temp != RIVER) && (Rand(1)))
        !           341:          temp++;
        !           342:        Map[MapX][MapY] = temp;
        !           343:       }
        !           344:     }
        !           345:   }
        !           346: }
        !           347: 
        !           348: 
        !           349: IsTree(int cell)
        !           350: {
        !           351:   if (((cell & LOMASK) >= WOODS_LOW) &&
        !           352:       ((cell & LOMASK) <= WOODS_HIGH))
        !           353:     return TRUE;
        !           354:   return FALSE;
        !           355: }
        !           356:  
        !           357: 
        !           358: SmoothTrees(void)
        !           359: {
        !           360:   static short DX[4] = {-1, 0, 1, 0};
        !           361:   static short DY[4] = { 0, 1, 0,-1};
        !           362:   static short TEdTab[16] = { 0, 0, 0, 34,
        !           363:                              0, 0, 36, 35,
        !           364:                              0, 32, 0, 33,
        !           365:                              30, 31, 29, 37 };
        !           366:   short   bitindex, z, Xtem, Ytem;
        !           367:   register short temp, MapX, MapY;
        !           368: 
        !           369:   for (MapX = 0; MapX < WORLD_X; MapX++) {
        !           370:     for (MapY = 0; MapY < WORLD_Y; MapY++) {
        !           371:       if (IsTree(Map[MapX][MapY])) {
        !           372:        bitindex = 0;
        !           373:        for (z = 0; z < 4; z++) {
        !           374:          bitindex = bitindex << 1;
        !           375:          Xtem = MapX + DX[z];
        !           376:          Ytem = MapY + DY[z];
        !           377:          if (TestBounds(Xtem, Ytem) &&
        !           378:              IsTree(Map[Xtem][Ytem])) {
        !           379:            bitindex++;
        !           380:          }
        !           381:        }
        !           382:        temp = TEdTab[bitindex & 15];
        !           383:        if (temp) {
        !           384:          if (temp != WOODS)
        !           385:            if ((MapX + MapY) & 1)
        !           386:              temp = temp - 8;
        !           387:          Map[MapX][MapY] = temp + BLBNBIT;
        !           388:        }
        !           389:        else Map[MapX][MapY] = temp;
        !           390:       }
        !           391:     }
        !           392:   }
        !           393: }
        !           394: 
        !           395: 
        !           396: DoRivers(void)
        !           397: {      
        !           398: 
        !           399:   LastDir = Rand(3);
        !           400:   Dir = LastDir;
        !           401:   DoBRiv();
        !           402:   MapX = XStart;
        !           403:   MapY = YStart;
        !           404:   LastDir = LastDir ^ 4;
        !           405:   Dir = LastDir;
        !           406:   DoBRiv();    
        !           407:   MapX = XStart;
        !           408:   MapY = YStart;
        !           409:   LastDir = Rand(3);
        !           410:   DoSRiv();
        !           411: }
        !           412: 
        !           413: 
        !           414: DoBRiv(void)
        !           415: {
        !           416:   int r1, r2;
        !           417: 
        !           418:   if (CurveLevel < 0) {
        !           419:     r1 = 100;
        !           420:     r2 = 200;
        !           421:   } else {
        !           422:     r1 = CurveLevel + 10;
        !           423:     r2 = CurveLevel + 100;
        !           424:   }
        !           425: 
        !           426:   while (TestBounds (MapX + 4, MapY + 4)) {
        !           427:     BRivPlop();
        !           428:     if (Rand(r1) < 10) {
        !           429:       Dir = LastDir;
        !           430:     } else {
        !           431:       if (Rand(r2) > 90) Dir++;
        !           432:       if (Rand(r2) > 90) Dir--;
        !           433:     }
        !           434:     MoveMap(Dir);
        !           435:   }
        !           436: }
        !           437: 
        !           438: 
        !           439: DoSRiv(void)
        !           440: {
        !           441:   int r1, r2;
        !           442: 
        !           443:   if (CurveLevel < 0) {
        !           444:     r1 = 100;
        !           445:     r2 = 200;
        !           446:   } else {
        !           447:     r1 = CurveLevel + 10;
        !           448:     r2 = CurveLevel + 100;
        !           449:   }
        !           450: 
        !           451:   while (TestBounds (MapX + 3, MapY + 3)) {
        !           452:     SRivPlop();
        !           453:     if (Rand(r1) < 10) {
        !           454:       Dir = LastDir;
        !           455:     } else {
        !           456:       if (Rand(r2) > 90) Dir++;
        !           457:       if (Rand(r2) > 90) Dir--;
        !           458:     }
        !           459:     MoveMap(Dir);
        !           460:   }
        !           461: }
        !           462: 
        !           463: 
        !           464: PutOnMap(short Mchar, short Xoff, short Yoff)
        !           465: {
        !           466:   register short Xloc, Yloc, temp;
        !           467: 
        !           468:   if (Mchar == 0)
        !           469:     return;
        !           470:   Xloc = MapX + Xoff;
        !           471:   Yloc = MapY + Yoff;
        !           472:   if (TestBounds(Xloc, Yloc) == FALSE)
        !           473:     return;
        !           474:   if (temp = Map[Xloc][Yloc]) {
        !           475:     temp = temp & LOMASK;
        !           476:     if (temp == RIVER)
        !           477:       if (Mchar != CHANNEL)
        !           478:        return;
        !           479:     if (temp == CHANNEL)
        !           480:       return;
        !           481:   }
        !           482:   Map[Xloc][Yloc] = Mchar;     
        !           483: }
        !           484: 
        !           485: 
        !           486: BRivPlop(void)
        !           487: {
        !           488:   static short BRMatrix[9][9] = {
        !           489:     { 0, 0, 0, 3, 3, 3, 0, 0, 0 },
        !           490:     { 0, 0, 3, 2, 2, 2, 3, 0, 0 },
        !           491:     { 0, 3, 2, 2, 2, 2, 2, 3, 0 },
        !           492:     { 3, 2, 2, 2, 2, 2, 2, 2, 3 },
        !           493:     { 3, 2, 2, 2, 4, 2, 2, 2, 3 },
        !           494:     { 3, 2, 2, 2, 2, 2, 2, 2, 3 },
        !           495:     { 0, 3, 2, 2, 2, 2, 2, 3, 0 },
        !           496:     { 0, 0, 3, 2, 2, 2, 3, 0, 0 },
        !           497:     { 0, 0, 0, 3, 3, 3, 0, 0, 0 } };
        !           498:   short x, y;
        !           499: 
        !           500:   for (x = 0; x < 9; x++)
        !           501:     for (y = 0; y < 9; y++)
        !           502:       PutOnMap(BRMatrix[y][x], x, y);
        !           503: }
        !           504: 
        !           505: 
        !           506: SRivPlop(void)
        !           507: {
        !           508:   static short SRMatrix[6][6] = {
        !           509:     { 0, 0, 3, 3, 0, 0 },
        !           510:     { 0, 3, 2, 2, 3, 0 },
        !           511:     { 3, 2, 2, 2, 2, 3 },
        !           512:     { 3, 2, 2, 2, 2, 3 },
        !           513:     { 0, 3, 2, 2, 3, 0 },
        !           514:     { 0, 0, 3, 3, 0, 0 } };
        !           515:   short x, y;
        !           516: 
        !           517:   for (x = 0; x < 6; x++)
        !           518:     for (y = 0; y < 6; y++)
        !           519:       PutOnMap(SRMatrix[y][x], x, y);
        !           520: }
        !           521: 
        !           522: 
        !           523: SmoothWater()
        !           524: {
        !           525:   int x, y;
        !           526: 
        !           527:   for(x = 0; x < WORLD_X; x++) {
        !           528:     for(y = 0; y < WORLD_Y; y++) {
        !           529:       /* If water: */
        !           530:       if (((Map[x][y] & LOMASK) >= WATER_LOW) &&
        !           531:          ((Map[x][y] & LOMASK) <= WATER_HIGH)) {
        !           532:        if (x > 0) {
        !           533:          /* If nearest object is not water: */
        !           534:          if (((Map[x - 1][y] & LOMASK) < WATER_LOW) ||
        !           535:              ((Map[x - 1][y] & LOMASK) > WATER_HIGH)) {
        !           536:            goto edge;
        !           537:          }
        !           538:        }
        !           539:        if (x < (WORLD_X - 1)) {
        !           540:          /* If nearest object is not water: */
        !           541:          if (((Map[x+1][y]&LOMASK) < WATER_LOW) ||
        !           542:              ((Map[x+1][y]&LOMASK) > WATER_HIGH)) {
        !           543:            goto edge;
        !           544:          }
        !           545:        }
        !           546:        if (y > 0) {
        !           547:          /* If nearest object is not water: */
        !           548:          if (((Map[x][y - 1] & LOMASK) < WATER_LOW) ||
        !           549:              ((Map[x][y-1]&LOMASK) > WATER_HIGH)) {
        !           550:            goto edge;
        !           551:          }
        !           552:        }
        !           553:        if (y < (WORLD_Y - 1)) {
        !           554:          /* If nearest object is not water: */
        !           555:          if (((Map[x][y + 1] & LOMASK) < WATER_LOW) ||
        !           556:              ((Map[x][y + 1] & LOMASK) > WATER_HIGH)) {
        !           557:          edge:
        !           558:            Map[x][y]=REDGE; /* set river edge */
        !           559:            continue;
        !           560:          }
        !           561:        }
        !           562:       }
        !           563:     }
        !           564:   }
        !           565:   for (x = 0; x < WORLD_X; x++) {
        !           566:     for (y = 0; y < WORLD_Y; y++) {
        !           567:       /* If water which is not a channel: */
        !           568:       if (((Map[x][y] & LOMASK) != CHANNEL) &&
        !           569:          ((Map[x][y] & LOMASK) >= WATER_LOW) &&
        !           570:          ((Map[x][y] & LOMASK) <= WATER_HIGH)) {
        !           571:        if (x > 0) {
        !           572:          /* If nearest object is not water; */
        !           573:          if (((Map[x - 1][y] & LOMASK) < WATER_LOW) ||
        !           574:              ((Map[x - 1][y] & LOMASK) > WATER_HIGH)) {
        !           575:            continue;
        !           576:          }
        !           577:        }
        !           578:        if (x < (WORLD_X - 1)) {
        !           579:          /* If nearest object is not water: */
        !           580:          if (((Map[x + 1][y] & LOMASK) < WATER_LOW) ||
        !           581:              ((Map[x + 1][y] & LOMASK) > WATER_HIGH)) {
        !           582:            continue;
        !           583:          }
        !           584:        }
        !           585:        if (y > 0) {
        !           586:          /* If nearest object is not water: */
        !           587:          if (((Map[x][y - 1] & LOMASK) < WATER_LOW) ||
        !           588:              ((Map[x][y - 1] & LOMASK) > WATER_HIGH)) {
        !           589:            continue;
        !           590:          }
        !           591:        }
        !           592:        if (y < (WORLD_Y - 1)) {
        !           593:          /* If nearest object is not water: */
        !           594:          if (((Map[x][y + 1] & LOMASK) < WATER_LOW) ||
        !           595:              ((Map[x][y + 1] & LOMASK) > WATER_HIGH)) {
        !           596:            continue;
        !           597:          }
        !           598:        }
        !           599:        Map[x][y] = RIVER; /* make it a river */
        !           600:       }
        !           601:     }
        !           602:   }
        !           603:   for (x = 0; x < WORLD_X; x++) {
        !           604:     for (y = 0; y < WORLD_Y; y++) {
        !           605:       /* If woods: */
        !           606:       if (((Map[x][y] & LOMASK) >= WOODS_LOW) &&
        !           607:          ((Map[x][y] & LOMASK) <= WOODS_HIGH)) {
        !           608:        if (x > 0) {
        !           609:          /* If nearest object is water: */
        !           610:          if ((Map[x - 1][y] == RIVER) ||
        !           611:              (Map[x - 1][y] == CHANNEL)) {
        !           612:            Map[x][y] = REDGE; /* make it water's edge */
        !           613:            continue;
        !           614:          }
        !           615:        }
        !           616:        if (x < (WORLD_X - 1)) {
        !           617:          /* If nearest object is water: */
        !           618:          if ((Map[x + 1][y] == RIVER) ||
        !           619:              (Map[x + 1][y] == CHANNEL)) {
        !           620:            Map[x][y] = REDGE; /* make it water's edge */
        !           621:            continue;
        !           622:          }
        !           623:        }
        !           624:        if (y > 0) {
        !           625:          /* If nearest object is water: */
        !           626:          if ((Map[x][y - 1] == RIVER) ||
        !           627:              (Map[x][y - 1] == CHANNEL)) {
        !           628:            Map[x][y] = REDGE; /* make it water's edge */
        !           629:            continue;
        !           630:          }
        !           631:        }
        !           632:        if (y < (WORLD_Y - 1)) {
        !           633:          /* If nearest object is water; */
        !           634:          if ((Map[x][y + 1] == RIVER) ||
        !           635:              (Map[x][y + 1] == CHANNEL)) {
        !           636:            Map[x][y] = REDGE; /* make it water's edge */
        !           637:            continue;
        !           638:          }
        !           639:        }
        !           640:       }
        !           641:     }
        !           642:   }
        !           643: }

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