zone.cpp

Go to the documentation of this file.

/* zone.cpp
 *
 * Micropolis, Unix Version.  This game was released for the Unix platform
 * in or about 1990 and has been modified for inclusion in the One Laptop
 * Per Child program.  Copyright (C) 1989 - 2007 Electronic Arts Inc.  If
 * you need assistance with this program, you may contact:
 *   http://wiki.laptop.org/go/Micropolis  or email  micropolis@laptop.org.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.  You should have received a
 * copy of the GNU General Public License along with this program.  If
 * not, see <http://www.gnu.org/licenses/>.
 *
 *             ADDITIONAL TERMS per GNU GPL Section 7
 *
 * No trademark or publicity rights are granted.  This license does NOT
 * give you any right, title or interest in the trademark SimCity or any
 * other Electronic Arts trademark.  You may not distribute any
 * modification of this program using the trademark SimCity or claim any
 * affliation or association with Electronic Arts Inc. or its employees.
 *
 * Any propagation or conveyance of this program must include this
 * copyright notice and these terms.
 *
 * If you convey this program (or any modifications of it) and assume
 * contractual liability for the program to recipients of it, you agree
 * to indemnify Electronic Arts for any liability that those contractual
 * assumptions impose on Electronic Arts.
 *
 * You may not misrepresent the origins of this program; modified
 * versions of the program must be marked as such and not identified as
 * the original program.
 *
 * This disclaimer supplements the one included in the General Public
 * License.  TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
 * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
 * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK.  THE ENTIRE RISK OF
 * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU.  ELECTRONIC ARTS
 * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
 * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
 * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
 * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
 * USAGE, OR TRADE PRACTICE.  ELECTRONIC ARTS DOES NOT WARRANT AGAINST
 * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
 * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
 * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
 * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
 * CORRECTED.  NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
 * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY.  SOME
 * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
 * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
 * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
 * NOT APPLY TO YOU.
 */
 
 
 
#include "micropolis.h"
 
 
 
 
void Micropolis::doZone(const Position &pos)
{
    // Set Power Bit in Map from powerGridMap
    bool zonePowerFlag = setZonePower(pos);
 
 
    if (zonePowerFlag) {
        poweredZoneCount++;
    } else {
        unpoweredZoneCount++;
    }
 
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    // Do special zones.
    if ((tile > PORTBASE) &&
        (tile < CHURCH1BASE)) {
        doSpecialZone(pos, zonePowerFlag);
        return;
    }
 
    // Do residential zones.
    if (tile < HOSPITAL) {
        doResidential(pos, zonePowerFlag);
        return;
    }
 
    // Do hospitals and churches.
    if ((tile < COMBASE) ||
        ((tile >= CHURCH1BASE) &&
         (tile <= CHURCH7LAST))) {
        doHospitalChurch(pos);
        return;
    }
 
    // Do commercial zones.
    if (tile < INDBASE)  {
        doCommercial(pos, zonePowerFlag);
        return;
    }
 
    // Do industrial zones.
    if (tile < CHURCH1BASE) {
        doIndustrial(pos, zonePowerFlag);
        return;
    }
 
    printf("UNEXPOECTED ZONE: %d !!!\n", tile);
}
 
void Micropolis::doHospitalChurch(const Position &pos)
{
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    if (tile == HOSPITAL) {
 
        hospitalPop++;
 
        if (!(cityTime & 15)) {
            repairZone(pos, HOSPITAL, 3);
        }
 
        if (needHospital == -1) { // Too many hospitals!
            if (!getRandom(20)) {
                zonePlop(pos, RESBASE); // Remove hospital.
            }
        }
 
    } else if ((tile == CHURCH0) ||
               (tile == CHURCH1) ||
               (tile == CHURCH2) ||
               (tile == CHURCH3) ||
               (tile == CHURCH4) ||
               (tile == CHURCH5) ||
               (tile == CHURCH6) ||
               (tile == CHURCH7)) {
 
        churchPop++;
 
        //printf("CHURCH %d %d %d %d\n", churchPop, pos.posX, pos.posY, tile);
 
        bool simulate = true;
 
        if (!(cityTime & 15)) {
            repairZone(pos, tile, 3);
        }
 
        if (needChurch == -1) { // Too many churches!
            if (!getRandom(20)) {
                zonePlop(pos, RESBASE); // Remove church.
                simulate = false;
            }
        }
 
        if (simulate) {
            //printf("SIM %d %d %d\n", pos.posX, pos.posY, tile);
 
            int churchNumber = 0;
            
            switch (tile) {
                case CHURCH0:
                churchNumber = 0;
                break;
                case CHURCH1:
                churchNumber = 1;
                break;
                case CHURCH2:
                churchNumber = 2;
                break;
                case CHURCH3:
                churchNumber = 3;
                break;
                case CHURCH4:
                churchNumber = 4;
                break;
                case CHURCH5:
                churchNumber = 5;
                break;
                case CHURCH6:
                churchNumber = 6;
                break;
                case CHURCH7:
                churchNumber = 7;
                break;
                    default:
                assert(0); // Unexpected church tile
                break;
            }
 
            callback->simulateChurch(this, callbackVal, pos.posX, pos.posY, churchNumber);
        }
 
    }
 
}
 
 
#define ASCBIT (ANIMBIT | CONDBIT | BURNBIT)
#define REGBIT (CONDBIT | BURNBIT)
 
void Micropolis::setSmoke(const Position &pos, bool zonePower)
{
    static bool aniThis[8] = {  true, false, true, true, false, false, true, true };
    static short dx1[8]     = {   -1,    0,    1,    0,    0,    0,    0,    1 };
    static short dy1[8]     = {   -1,    0,   -1,   -1,    0,    0,   -1,   -1 };
    static short aniTabA[8] = {    0,    0,   32,   40,    0,    0,   48,   56 };
    static short aniTabB[8] = {    0,    0,   36,   44,    0,    0,   52,   60 };
    static short aniTabC[8] = { IND1,    0, IND2, IND4,    0,    0, IND6, IND8 };
    static short aniTabD[8] = { IND1,    0, IND3, IND5,    0,    0, IND7, IND9 };
 
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    if (tile < IZB) {
        return;
    }
 
    int z = (tile - IZB) >>3; 
    z = z & 7;
 
    if (aniThis[z]) {
        int xx = pos.posX + dx1[z];
        int yy = pos.posY + dy1[z];
 
        if (testBounds(xx, yy)) {
 
            if (zonePower) {
 
                if ((map[xx][yy] & LOMASK) == aniTabC[z]) {
                    map[xx][yy] = ASCBIT | (SMOKEBASE + aniTabA[z]);
                    map[xx][yy] = ASCBIT | (SMOKEBASE + aniTabB[z]);
                }
 
            } else {
 
                if ((map[xx][yy] & LOMASK) > aniTabC[z]) {
                  map[xx][yy] = REGBIT | aniTabC[z];
                  map[xx][yy] = REGBIT | aniTabD[z];
                }
 
            }
 
        }
 
    }
 
}
 
 
void Micropolis::makeHospital(const Position &pos)
{
    if (needHospital > 0) {
        zonePlop(pos, HOSPITAL - 4);
        needHospital = 0;
        return;
    }
 
    if (needChurch > 0) {
        int churchType = getRandom(7); // 0 to 7 inclusive
        int tile;
        if (churchType == 0) {
            tile = CHURCH0;
        } else {
            tile = CHURCH1 + ((churchType - 1) * 9);
        }
 
       //printf("NEW CHURCH tile %d x %d y %d type %d\n", tile, pos.posX, pos.posY, churchType);
 
        zonePlop(pos, tile - 4);
        needChurch = 0;
        return;
    }
}
 
short Micropolis::getLandPollutionValue(const Position &pos)
{
    short landVal;
 
    landVal =  landValueMap.worldGet(pos.posX, pos.posY);
    landVal -= pollutionDensityMap.worldGet(pos.posX, pos.posY);
 
    if (landVal < 30) {
        return 0;
    }
 
    if (landVal < 80) {
        return 1;
    }
 
    if (landVal < 150) {
        return 2;
    }
 
    return 3;
}
 
 
void Micropolis::incRateOfGrowth(const Position &pos, int amount)
{
    int value = rateOfGrowthMap.worldGet(pos.posX, pos.posY);
 
    value = clamp(value + amount * 4, -200, 200);
    rateOfGrowthMap.worldSet(pos.posX, pos.posY, value);
}
 
 
bool Micropolis::zonePlop(const Position &pos, int base)
{
    short z, x;
    static const short Zx[9] = {-1, 0, 1,-1, 0, 1,-1, 0, 1};
    static const short Zy[9] = {-1,-1,-1, 0, 0, 0, 1, 1, 1};
 
    for (z = 0; z < 9; z++) {             /* check for fire  */
        int xx = pos.posX + Zx[z];
        int yy = pos.posY + Zy[z];
 
        if (testBounds(xx, yy)) {
            x = map[xx][yy] & LOMASK;
 
            if ((x >= FLOOD) && (x < ROADBASE)) {
                return false;
            }
 
        }
 
    }
 
    for (z = 0; z < 9; z++) {
        int xx = pos.posX + Zx[z];
        int yy = pos.posY + Zy[z];
 
        if (testBounds(xx, yy)) {
            map[xx][yy] = base + BNCNBIT;
        }
 
        base++;
    }
 
    setZonePower(pos);
    map[pos.posX][pos.posY] |= ZONEBIT + BULLBIT;
 
    return true;
}
 
short Micropolis::doFreePop(const Position &pos)
{
    short count = 0;
 
    for (short x = pos.posX - 1; x <= pos.posX + 1; x++) {
        for (short y = pos.posY - 1; y <= pos.posY + 1; y++) {
            if (x >= 0 && x < WORLD_W && y >= 0 && y < WORLD_H) {
                MapTile tile = map[x][y] & LOMASK;
                if (tile >= LHTHR && tile <= HHTHR) {
                    count++;
                }
            }
        }
    }
 
    return count;
}
 
 
bool Micropolis::setZonePower(const Position &pos)
{
    MapValue mapValue = map[pos.posX][pos.posY];
    MapTile tile = mapValue & LOMASK;
 
    if (tile == NUCLEAR || tile == POWERPLANT) {
        map[pos.posX][pos.posY] = mapValue | PWRBIT;
        return true;
    }
 
    if (powerGridMap.worldGet(pos.posX, pos.posY)) {
        map[pos.posX][pos.posY] = mapValue | PWRBIT;
        return true;
    } else {
        map[pos.posX][pos.posY] = mapValue & (~PWRBIT);
        return false;
    }
}
 
 
void Micropolis::buildHouse(const Position &pos, int value)
{
    short z, score, hscore, BestLoc;
    static short ZeX[9] = { 0,-1, 0, 1,-1, 1,-1, 0, 1};
    static short ZeY[9] = { 0,-1,-1,-1, 0, 0, 1, 1, 1};
 
    BestLoc = 0;
    hscore = 0;
 
    for (z = 1; z < 9; z++) {
        int xx = pos.posX + ZeX[z];
        int yy = pos.posY + ZeY[z];
 
        if (testBounds(xx, yy)) {
 
            score = evalLot(xx, yy);
 
            if (score != 0) {
 
                if (score > hscore) {
                    hscore = score;
                    BestLoc = z;
                }
 
                //        trigger this code too.
                if (score == hscore && !(getRandom16() & 7)) {
                    BestLoc = z;
                }
 
            }
 
        }
 
    }
 
    if (BestLoc) {
        int xx = pos.posX + ZeX[BestLoc];
        int yy = pos.posY + ZeY[BestLoc];
 
        if (testBounds(xx, yy)) {
            map[xx][yy] = HOUSE + BLBNCNBIT + getRandom(2) + value * 3;
        }
 
    }
}
 
 
short Micropolis::evalLot(int x, int y)
{
    short z, score;
    static short DX[4] = { 0, 1, 0,-1};
    static short DY[4] = {-1, 0, 1, 0};
 
    /* test for clear lot */
    z = map[x][y] & LOMASK;
 
    if (z && (z < RESBASE || z > RESBASE + 8)) {
        return -1;
    }
 
    score = 1;
 
    for (z = 0; z < 4; z++) {
        int xx = x + DX[z];
        int yy = y + DY[z];
 
        if (testBounds(xx, yy) &&
            map[xx][yy] != DIRT && (map[xx][yy] & LOMASK) <= LASTROAD) {
            score++;          /* look for road */
        }
 
    }
 
    return score;
}
 
void Micropolis::doResidential(const Position &pos, bool zonePower)
{
    short tpop, zscore, locvalve, value, TrfGood;
 
    resZonePop++;
 
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    if (tile == FREEZ) {
        tpop = doFreePop(pos);
    } else {
        tpop = getResZonePop(tile);
    }
 
    resPop += tpop;
 
    if (tpop > getRandom(35)) {
        /* Try driving from residential to commercial */
        TrfGood = makeTraffic(pos, ZT_COMMERCIAL);
    } else {
        TrfGood = 1;
    }
 
    if (TrfGood == -1) {
        value = getLandPollutionValue(pos);
        doResOut(pos, tpop, value);
        return;
    }
 
    if (tile == FREEZ || !(getRandom16() & 7)) {
 
        locvalve = evalRes(pos, TrfGood);
        zscore = resValve + locvalve;
 
        if (!zonePower) {
            zscore = -500;
        }
 
        if (zscore > -350 &&
            ((short)(zscore - 26380) > ((short)getRandom16Signed()))) {
 
            if (!tpop && !(getRandom16() & 3)) {
                makeHospital(pos);
                return;
            }
 
            value = getLandPollutionValue(pos);
            doResIn(pos, tpop, value);
            return;
        }
 
        if (zscore < 350 &&
            (((short)(zscore + 26380)) < ((short)getRandom16Signed()))) {
            value = getLandPollutionValue(pos);
            doResOut(pos, tpop, value);
        }
    }
}
 
 
void Micropolis::doResIn(const Position &pos, int pop, int value)
{
    short pollution = pollutionDensityMap.worldGet(pos.posX, pos.posY);
 
    if (pollution > 128) {
        return;
    }
 
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    if (tile == FREEZ) {
 
        if (pop < 8) {
            buildHouse(pos, value);
            incRateOfGrowth(pos, 1);
            return;
        }
 
        if (populationDensityMap.worldGet(pos.posX, pos.posY) > 64) {
            resPlop(pos, 0, value);
            incRateOfGrowth(pos, 8);
            return;
        }
 
        return;
    }
 
    if (pop < 40) {
        resPlop(pos, (pop / 8) - 1, value);
        incRateOfGrowth(pos, 8);
    }
 
}
 
 
void Micropolis::doResOut(const Position &pos, int pop, int value)
{
    static short Brdr[9] = {0,3,6,1,4,7,2,5,8};
    short x, y, loc, z;
 
    if (!pop) {
        return;
    }
 
    if (pop > 16) {
        resPlop(pos, (pop - 24) / 8, value);
        incRateOfGrowth(pos, -8);
        return;
    }
 
    if (pop == 16) {
        incRateOfGrowth(pos, -8);
        map[pos.posX][pos.posY] = (FREEZ | BLBNCNBIT | ZONEBIT);
        for (x = pos.posX - 1; x <= pos.posX + 1; x++) {
            for (y = pos.posY - 1; y <= pos.posY + 1; y++) {
                if (testBounds(x, y)) {
                    if ((map[x][y] & LOMASK) != FREEZ) {
                        map[x][y] = LHTHR + value + getRandom(2) + BLBNCNBIT;
                    }
                }
            }
        }
    }
 
    if (pop < 16) {
        incRateOfGrowth(pos, -1);
        z = 0;
        for (x = pos.posX - 1; x <= pos.posX + 1; x++) {
            for (y = pos.posY - 1; y <= pos.posY + 1; y++) {
                if (testBounds(x, y)) {
                    loc = map[x][y] & LOMASK;
                    if ((loc >= LHTHR) && (loc <= HHTHR)) {
                        map[x][y] = Brdr[z] + BLBNCNBIT + FREEZ - 4;
                        return;
                    }
                }
                z++;
            }
        }
    }
}
 
 
short Micropolis::getResZonePop(MapTile mapTile)
{
    short CzDen = ((mapTile - RZB) / 9) % 4;
 
    return CzDen * 8 + 16;
}
 
void Micropolis::resPlop(const Position &pos, int den, int value)
{
    short base;
 
    base = ((value * 4 + den) * 9) + RZB - 4;
    zonePlop(pos, base);
}
 
 
short Micropolis::evalRes(const Position &pos, int traf)
{
    short value;
 
    if (traf < 0) {
        return -3000;
    }
 
    value =  landValueMap.worldGet(pos.posX, pos.posY);
    value -= pollutionDensityMap.worldGet(pos.posX, pos.posY);
 
    if (value < 0) {
        value = 0;          /* Cap at 0 */
    } else {
        value = min(value * 32, 6000); /* Cap at 6000 */
    }
 
    value = value - 3000;
 
    return value;
}
 
 
void Micropolis::doCommercial(const Position &pos, bool zonePower)
{
    short tpop, TrfGood;
    short zscore, locvalve, value;
 
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    comZonePop++;
    tpop = getComZonePop(tile);
    comPop += tpop;
 
    if (tpop > getRandom(5)) {
        /* Try driving from commercial to industrial */
        TrfGood = makeTraffic(pos, ZT_INDUSTRIAL);
    } else {
        TrfGood = 1;
    }
 
    if (TrfGood == -1) {
        value = getLandPollutionValue(pos);
        doComOut(pos, tpop, value);
        return;
    }
 
    if (!(getRandom16() & 7)) {
 
        locvalve = evalCom(pos, TrfGood);
        zscore = comValve + locvalve;
 
        if (!zonePower) {
            zscore = -500;
        }
 
        if (TrfGood &&
            (zscore > -350) &&
            (((short)(zscore - 26380)) > ((short)getRandom16Signed()))) {
            value = getLandPollutionValue(pos);
            doComIn(pos, tpop, value);
            return;
        }
 
        if ((zscore < 350) &&
            (((short)(zscore + 26380)) < ((short)getRandom16Signed()))) {
            value = getLandPollutionValue(pos);
            doComOut(pos, tpop, value);
        }
 
    }
 
}
 
 
void Micropolis::doComIn(const Position &pos, int pop, int value)
{
    short z;
 
    z = landValueMap.worldGet(pos.posX, pos.posY);
    z = z >>5;
 
    if (pop > z) {
        return;
    }
 
    if (pop < 5) {
        comPlop(pos, pop, value);
        incRateOfGrowth(pos, 8);
    }
}
 
void Micropolis::doComOut(const Position &pos, int pop, int value)
{
    if (pop > 1) {
        comPlop(pos, pop - 2, value);
        incRateOfGrowth(pos, -8);
        return;
    }
 
    if (pop == 1) {
        zonePlop(pos, COMBASE);
        incRateOfGrowth(pos, -8);
    }
}
 
 
short Micropolis::getComZonePop(MapTile tile)
{
    if (tile == COMCLR) {
        return 0;
    }
 
    short CzDen = ((tile - CZB) / 9) % 5 + 1;
    return CzDen;
}
 
 
void Micropolis::comPlop(const Position &pos, int Den, int Value)
{
    short base;
 
    base = ((Value * 5) + Den) * 9 + CZB - 4;
    zonePlop(pos, base);
}
 
 
short Micropolis::evalCom(const Position &pos, int traf)
{
    short Value;
 
    if (traf < 0) {
        return -3000;
    }
 
    Value = comRateMap.worldGet(pos.posX, pos.posY);
 
    return Value;
}
 
 
void Micropolis::doIndustrial(const Position &pos, bool zonePower)
{
    short tpop, zscore, TrfGood;
 
    MapTile tile = map[pos.posX][pos.posY] & LOMASK;
 
    indZonePop++;
    setSmoke(pos, zonePower);
    tpop = getIndZonePop(tile);
    indPop += tpop;
 
    if (tpop > getRandom(5)) {
        /* Try driving from industrial to residential */
        TrfGood = makeTraffic(pos, ZT_RESIDENTIAL);
    } else {
        TrfGood = 1;
    }
 
    if (TrfGood == -1) {
        doIndOut(pos, tpop, getRandom16() & 1);
        return;
    }
 
    if (!(getRandom16() & 7)) {
        zscore = indValve + evalInd(TrfGood);
 
        if (!zonePower) {
            zscore = -500;
        }
 
        if (zscore > -350 &&
            (((short)(zscore - 26380)) > ((short)getRandom16Signed()))) {
            doIndIn(pos, tpop, getRandom16() & 1);
            return;
        }
 
        if (zscore < 350 &&
            (((short)(zscore + 26380)) < ((short)getRandom16Signed()))) {
            doIndOut(pos, tpop, getRandom16() & 1);
        }
    }
}
 
 
void Micropolis::doIndIn(const Position &pos, int pop, int value)
{
    if (pop < 4) {
        indPlop(pos, pop, value);
        incRateOfGrowth(pos, 8);
    }
}
 
void Micropolis::doIndOut(const Position &pos, int pop, int value)
{
    if (pop > 1) {
        indPlop(pos, pop - 2, value);
        incRateOfGrowth(pos, -8);
        return;
    }
 
    if (pop == 1) {
        zonePlop(pos, INDBASE); // empty industrial zone
        incRateOfGrowth(pos, -8);
    }
}
 
 
short Micropolis::getIndZonePop(MapTile tile)
{
    if (tile == INDCLR) {
        return 0;
    }
 
    short CzDen = (((tile - IZB) / 9) % 4) + 1;
    return CzDen;
}
 
void Micropolis::indPlop(const Position &pos, int den, int value)
{
    short base = ((value * 4) + den) * 9 + IND1;
    zonePlop(pos, base);
}
 
 
short Micropolis::evalInd(int traf)
{
    if (traf < 0) {
        return -1000;
    }
 
    return 0;
}