Return to s_power.c CVS log

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

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

1.1     ! root        1: /* s_power.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: /* Power Scan */
        !            66: 
        !            67: 
        !            68: int PowerStackNum;
        !            69: char PowerStackX[PWRSTKSIZE], PowerStackY[PWRSTKSIZE];
        !            70: QUAD MaxPower, NumPower;
        !            71: 
        !            72: 
        !            73: /* comefrom: TestForCond DoPowerScan TryGo */
        !            74: MoveMapSim (short MDir)
        !            75: {
        !            76:   switch (MDir) {
        !            77:   case 0:
        !            78:     if (SMapY > 0) {
        !            79:       SMapY--;
        !            80:       return (TRUE);
        !            81:     }
        !            82:     if (SMapY < 0)
        !            83:       SMapY = 0;
        !            84:     return (FALSE);
        !            85:   case 1:
        !            86:     if (SMapX < (WORLD_X - 1)) {
        !            87:       SMapX++;
        !            88:       return (TRUE);
        !            89:     }
        !            90:     if (SMapX > (WORLD_X - 1))
        !            91:       SMapX = WORLD_X - 1;
        !            92:     return (FALSE);
        !            93:   case 2:
        !            94:     if (SMapY < (WORLD_Y - 1)) {
        !            95:       SMapY++;
        !            96:       return (TRUE);
        !            97:     }
        !            98:     if (SMapY > (WORLD_Y - 1))
        !            99:       SMapY = WORLD_Y - 1;
        !           100:     return (FALSE);
        !           101:   case 3:
        !           102:     if (SMapX > 0) {
        !           103:       SMapX--;
        !           104:       return (TRUE);
        !           105:     }
        !           106:     if (SMapX < 0)
        !           107:       SMapX = 0;
        !           108:     return (FALSE);
        !           109:   case 4:
        !           110:     return (TRUE);
        !           111:   }
        !           112:   return (FALSE);                              
        !           113: }
        !           114: 
        !           115: 
        !           116: /* inlined -Don */
        !           117: #if 0
        !           118: /* comefrom: DoPowerScan */
        !           119: SetPowerBit(void) 
        !           120: {
        !           121:   register int PowerWrd;
        !           122: 
        !           123:   /* XXX: assumes 120x100 */
        !           124:   PowerWrd = (SMapX >>4) + (SMapY <<3);
        !           125:   PowerMap[PowerWrd] |= 1 << (SMapX & 15);
        !           126: }
        !           127: #endif
        !           128: 
        !           129: 
        !           130: /* inlined */
        !           131: #if 0
        !           132: /* comefrom: TestForCond */
        !           133: int TestPowerBit(void)
        !           134: {
        !           135:   register int PowerWrd;
        !           136: 
        !           137:   if ((CChr9 == NUCLEAR) || (CChr9 == POWERPLANT))
        !           138:     return(1);
        !           139:   /* XXX: assumes 120x100 */
        !           140:   PowerWrd = (SMapX >>4) + (SMapY <<3);
        !           141:   if (PowerWrd >= PWRMAPSIZE)
        !           142:     return(0);
        !           143:   return ((PowerMap[PowerWrd] & (1 << (SMapX & 15))) ? 1 : 0);
        !           144: }
        !           145: #endif
        !           146: 
        !           147: 
        !           148: /* comefrom: DoPowerScan */
        !           149: short TestForCond(short TFDir)
        !           150: {      
        !           151:   register int xsave, ysave, PowerWrd;
        !           152: 
        !           153:   xsave = SMapX;
        !           154:   ysave = SMapY;
        !           155:   if (MoveMapSim(TFDir)) {
        !           156:     /* TestPowerBit was taking a lot of time so I swapped the & order -Don */
        !           157: #if 0
        !           158:     if ((Map[SMapX][SMapY] & CONDBIT) &&
        !           159:        (!TestPowerBit()))
        !           160: #else
        !           161:     if ((Map[SMapX][SMapY] & CONDBIT) &&
        !           162:        (CChr9 != NUCLEAR) &&
        !           163:        (CChr9 != POWERPLANT) &&
        !           164:        (
        !           165: #if 0
        !           166:         (PowerWrd = (SMapX >>4) + (SMapY <<3)),
        !           167: #else
        !           168:         (PowerWrd = POWERWORD(SMapX, SMapY)),
        !           169: #endif
        !           170:         ((PowerWrd > PWRMAPSIZE) ||
        !           171:          ((PowerMap[PowerWrd] & (1 << (SMapX & 15))) == 0))))
        !           172: #endif
        !           173:     {
        !           174:       SMapX = xsave;
        !           175:       SMapY = ysave;
        !           176:       return (TRUE);
        !           177:     }
        !           178:   }
        !           179:   SMapX = xsave;
        !           180:   SMapY = ysave;
        !           181:   return (FALSE);
        !           182: }
        !           183: 
        !           184: 
        !           185: /* comefrom: Simulate SpecialInit InitSimMemory */
        !           186: DoPowerScan()
        !           187: {      
        !           188:   short ADir;
        !           189:   register int ConNum, Dir, x;
        !           190: 
        !           191:   for (x = 0; x < PWRMAPSIZE; x++)
        !           192:     PowerMap[x] = 0;   /* ClearPowerMem */
        !           193: 
        !           194:   MaxPower = (CoalPop * 700L) + (NuclearPop * 2000L); /* post release */
        !           195:   NumPower = 0;
        !           196: 
        !           197:   while (PowerStackNum)        {
        !           198:     PullPowerStack();
        !           199:     ADir = 4;
        !           200:     do {
        !           201:       if (++NumPower > MaxPower) {
        !           202:        SendMes(40);
        !           203:        return;
        !           204:       }
        !           205:       MoveMapSim(ADir);
        !           206: /* inlined -Don */
        !           207: #if 0
        !           208:       SetPowerBit();
        !           209: #else
        !           210: #if 1
        !           211:       SETPOWERBIT(SMapX, SMapY);
        !           212: #else
        !           213:       PowerMap[(SMapX >>4) + (SMapY <<3)] |= 1 << (SMapX & 15);
        !           214: #endif
        !           215: #endif
        !           216:       ConNum = 0;
        !           217:       Dir = 0;
        !           218:       while ((Dir < 4) && (ConNum < 2))        {
        !           219:        if (TestForCond(Dir)) {
        !           220:          ConNum++;
        !           221:          ADir = Dir;
        !           222:        }
        !           223:        Dir++;
        !           224:       }
        !           225:       if (ConNum > 1)
        !           226:        PushPowerStack();
        !           227:     } while (ConNum);
        !           228:   }
        !           229: }
        !           230: 
        !           231: 
        !           232: /* comefrom: DoPowerScan DoSPZone */
        !           233: PushPowerStack(void) 
        !           234: {      
        !           235:   if (PowerStackNum < (PWRSTKSIZE - 2)) {
        !           236:     PowerStackNum++;
        !           237:     PowerStackX[PowerStackNum] = SMapX;
        !           238:     PowerStackY[PowerStackNum] = SMapY;
        !           239:    }
        !           240: }
        !           241: 
        !           242: 
        !           243: /* comefrom: DoPowerScan */
        !           244: PullPowerStack(void)
        !           245: {      
        !           246:   if (PowerStackNum > 0)  {
        !           247:     SMapX = PowerStackX[PowerStackNum];
        !           248:     SMapY = PowerStackY[PowerStackNum];
        !           249:     PowerStackNum--;
        !           250:   }
        !           251: }
        !           252: 
        !           253: 

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