MicropolisEngine/src/micropolis.h

Go to the documentation of this file.

/* micropolis.h
 *
 * 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.
 */


// Includes


#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <cstdarg>

#ifdef _WIN32

#include <winsock2.h>
#include <sys/stat.h>
#include <time.h>

#ifndef S_ISDIR
#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
#endif

#else

#ifdef __APPLE__
#include <sys/stat.h>
#endif

#include <unistd.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/types.h>

#endif

#include <string>
#include <vector>
#include <map>

#include "data_types.h"
#include "map_type.h"
#include "position.h"

// Definitions


#define IS_INTEL                        1

#define MICROPOLIS_VERSION              "5.0"


// Constants


static const int BITS_PER_TILE = 16;

static const int BYTES_PER_TILE = 2;

static const int WORLD_W_2 = WORLD_W / 2;

static const int WORLD_H_2 = WORLD_H / 2;

static const int WORLD_W_4 = WORLD_W / 4;

static const int WORLD_H_4 = WORLD_H / 4;

static const int WORLD_W_8 = WORLD_W / 8;

static const int WORLD_H_8 = (WORLD_H + 7) / 8;

static const int EDITOR_TILE_SIZE = 16;

static const int PASSES_PER_CITYTIME = 16;

static const int CITYTIMES_PER_MONTH = 4;

static const int CITYTIMES_PER_YEAR = CITYTIMES_PER_MONTH * 12;

static const int HISTORY_LENGTH = 480;

static const int MISC_HISTORY_LENGTH = 240;

static const int HISTORY_COUNT = 120;

static const int POWER_STACK_SIZE = (WORLD_W * WORLD_H) / 4;


static const int NOWHERE = -1;


// Traffic

static const int MAX_TRAFFIC_DISTANCE = 30;

static const int MAX_ROAD_EFFECT = 32;

static const int MAX_POLICE_STATION_EFFECT = 1000;

static const int MAX_FIRE_STATION_EFFECT = 1000;


// Valves


static const int RES_VALVE_RANGE = 2000;
static const int COM_VALVE_RANGE = 1500;
static const int IND_VALVE_RANGE = 1500;


// Enumerated types.


enum HistoryType {
    HISTORY_TYPE_RES,   
    HISTORY_TYPE_COM,   
    HISTORY_TYPE_IND,   
    HISTORY_TYPE_MONEY, 
    HISTORY_TYPE_CRIME, 
    HISTORY_TYPE_POLLUTION, 

    HISTORY_TYPE_COUNT,  
};

enum HistoryScale {
    HISTORY_SCALE_SHORT, 
    HISTORY_SCALE_LONG,  

    HISTORY_SCALE_COUNT, 
};

enum MapType {
    MAP_TYPE_ALL,                   
    MAP_TYPE_RES,                   
    MAP_TYPE_COM,                   
    MAP_TYPE_IND,                   
    MAP_TYPE_POWER,                 
    MAP_TYPE_ROAD,                  
    MAP_TYPE_POPULATION_DENSITY,    
    MAP_TYPE_RATE_OF_GROWTH,        
    MAP_TYPE_TRAFFIC_DENSITY,       
    MAP_TYPE_POLLUTION,             
    MAP_TYPE_CRIME,                 
    MAP_TYPE_LAND_VALUE,            
    MAP_TYPE_FIRE_RADIUS,           
    MAP_TYPE_POLICE_RADIUS,         
    MAP_TYPE_DYNAMIC,               

    MAP_TYPE_COUNT,                 
};

/* Object & Sound Numbers */

enum SpriteType {
    SPRITE_NOTUSED = 0,

    SPRITE_TRAIN, 
    SPRITE_HELICOPTER, 
    SPRITE_AIRPLANE, 
    SPRITE_SHIP, 
    SPRITE_MONSTER, 
    SPRITE_TORNADO, 
    SPRITE_EXPLOSION, 
    SPRITE_BUS, 

    SPRITE_COUNT, 
};


// Tiles

typedef unsigned short MapValue;

typedef unsigned short MapTile;

enum MapTileBits {
    PWRBIT  = 0x8000, 
    CONDBIT = 0x4000, 
    BURNBIT = 0x2000, 
    BULLBIT = 0x1000, 
    ANIMBIT = 0x0800, 
    ZONEBIT = 0x0400, 

    ALLBITS = ZONEBIT | ANIMBIT | BULLBIT | BURNBIT | CONDBIT | PWRBIT,
    LOMASK = 0x03ff, 

    BLBNBIT   = BULLBIT | BURNBIT,
    BLBNCNBIT = BULLBIT | BURNBIT | CONDBIT,
    BNCNBIT   =           BURNBIT | CONDBIT,
};


enum ConnectTileCommand {
    CONNECT_TILE_FIX, 
    CONNECT_TILE_BULLDOZE, 
    CONNECT_TILE_ROAD, 
    CONNECT_TILE_RAILROAD, 
    CONNECT_TILE_WIRE, 
};


enum ToolResult {
    TOOLRESULT_NO_MONEY = -2,  
    TOOLRESULT_NEED_BULLDOZE = -1, 
    TOOLRESULT_FAILED = 0, 
    TOOLRESULT_OK = 1, 
};


enum MapTileCharacters {
    DIRT           = 0, 
    // tile 1 ?

    /* Water */
    RIVER          = 2,
    REDGE          = 3,
    CHANNEL        = 4,
    FIRSTRIVEDGE   = 5,
    // tile 6 -- 19 ?
    LASTRIVEDGE    = 20,
    WATER_LOW      = RIVER,       
    WATER_HIGH     = LASTRIVEDGE, 

    TREEBASE       = 21,
    WOODS_LOW      = TREEBASE,
    LASTTREE       = 36,
    WOODS          = 37,
    UNUSED_TRASH1  = 38,
    UNUSED_TRASH2  = 39,
    WOODS_HIGH     = UNUSED_TRASH2, // Why is an 'UNUSED' tile used?
    WOODS2         = 40,
    WOODS3         = 41,
    WOODS4         = 42,
    WOODS5         = 43,

    /* Rubble (4 tiles) */
    RUBBLE         = 44,
    LASTRUBBLE     = 47,

    FLOOD          = 48,
    // tile 49, 50 ?
    LASTFLOOD      = 51,

    RADTILE        = 52, 

    UNUSED_TRASH3  = 53,
    UNUSED_TRASH4  = 54,
    UNUSED_TRASH5  = 55,

    /* Fire animation (8 tiles) */
    FIRE           = 56,
    FIREBASE       = FIRE,
    LASTFIRE       = 63,

    HBRIDGE        = 64, 
    ROADBASE       = HBRIDGE,
    VBRIDGE        = 65, 
    ROADS          = 66,
    ROADS2         = 67,
    ROADS3         = 68,
    ROADS4         = 69,
    ROADS5         = 70,
    ROADS6         = 71,
    ROADS7         = 72,
    ROADS8         = 73,
    ROADS9         = 74,
    ROADS10        = 75,
    INTERSECTION   = 76,
    HROADPOWER     = 77,
    VROADPOWER     = 78,
    BRWH           = 79,
    LTRFBASE       = 80, 
    // tile 81 -- 94 ?
    BRWV           = 95,
    // tile 96 -- 110 ?
    BRWXXX1        = 111,
    // tile 96 -- 110 ?
    BRWXXX2        = 127,
    // tile 96 -- 110 ?
    BRWXXX3        = 143,
    HTRFBASE       = 144, 
    // tile 145 -- 158 ?
    BRWXXX4        = 159,
    // tile 160 -- 174 ?
    BRWXXX5        = 175,
    // tile 176 -- 190 ?
    BRWXXX6        = 191,
    // tile 192 -- 205 ?
    LASTROAD       = 206,
    BRWXXX7        = 207,

    /* Power lines */
    HPOWER         = 208,
    VPOWER         = 209,
    LHPOWER        = 210,
    LVPOWER        = 211,
    LVPOWER2       = 212,
    LVPOWER3       = 213,
    LVPOWER4       = 214,
    LVPOWER5       = 215,
    LVPOWER6       = 216,
    LVPOWER7       = 217,
    LVPOWER8       = 218,
    LVPOWER9       = 219,
    LVPOWER10      = 220,
    RAILHPOWERV    = 221, 
    RAILVPOWERH    = 222, 
    POWERBASE      = HPOWER,
    LASTPOWER      = RAILVPOWERH,

    UNUSED_TRASH6  = 223,

    /* Rail */
    HRAIL          = 224,
    VRAIL          = 225,
    LHRAIL         = 226,
    LVRAIL         = 227,
    LVRAIL2        = 228,
    LVRAIL3        = 229,
    LVRAIL4        = 230,
    LVRAIL5        = 231,
    LVRAIL6        = 232,
    LVRAIL7        = 233,
    LVRAIL8        = 234,
    LVRAIL9        = 235,
    LVRAIL10       = 236,
    HRAILROAD      = 237,
    VRAILROAD      = 238,
    RAILBASE       = HRAIL,
    LASTRAIL       = 238,

    ROADVPOWERH    = 239, /* bogus? */

    // Residential zone tiles

    RESBASE        = 240, // Empty residential, tiles 240--248
    FREEZ          = 244, // center-tile of 3x3 empty residential

    HOUSE          = 249, // Single tile houses until 260
    LHTHR          = HOUSE,
    HHTHR          = 260,

    RZB            = 265, // center tile first 3x3 tile residential

    HOSPITALBASE   = 405, // Center of hospital (tiles 405--413)
    HOSPITAL       = 409, // Center of hospital (tiles 405--413)

    CHURCHBASE     = 414, // Center of church (tiles 414--422)
    CHURCH0BASE    = 414, // numbered alias
    CHURCH         = 418, // Center of church (tiles 414--422)
    CHURCH0        = 418, // numbered alias

    // Commercial zone tiles

    COMBASE        = 423, // Empty commercial, tiles 423--431
    // tile 424 -- 426 ?
    COMCLR         = 427,
    // tile 428 -- 435 ?
    CZB            = 436,
    // tile 437 -- 608 ?
    COMLAST        = 609,
    // tile 610, 611 ?

    // Industrial zone tiles.
    INDBASE        = 612, 
    INDCLR         = 616, 
    LASTIND        = 620, 

    // Industrial zone population 0, value 0: 621 -- 629
    IND1           = 621, 
    IZB            = 625, 

    // Industrial zone population 1, value 0: 630 -- 638

    // Industrial zone population 2, value 0: 639 -- 647
    IND2           = 641,
    IND3           = 644,

    // Industrial zone population 3, value 0: 648 -- 656
    IND4           = 649,
    IND5           = 650,

    // Industrial zone population 0, value 1: 657 -- 665

    // Industrial zone population 1, value 1: 666 -- 674

    // Industrial zone population 2, value 1: 675 -- 683
    IND6           = 676,
    IND7           = 677,

    // Industrial zone population 3, value 1: 684 -- 692
    IND8           = 686,
    IND9           = 689,

    // Seaport
    PORTBASE       = 693, 
    PORT           = 698, 
    LASTPORT       = 708, 

    AIRPORTBASE    = 709,
    // tile 710 ?
    RADAR          = 711,
    // tile 712 -- 715 ?
    AIRPORT        = 716,
    // tile 717 -- 744 ?

    // Coal power plant (4x4).
    COALBASE       = 745, 
    POWERPLANT     = 750, 
    LASTPOWERPLANT = 760, 

    // Fire station (3x3).
    FIRESTBASE     = 761, 
    FIRESTATION    = 765, 
    // 769 last tile fire station.

    POLICESTBASE   = 770,
    // tile 771 -- 773 ?
    POLICESTATION  = 774,
    // tile 775 -- 778 ?

    // Stadium (4x4).
    STADIUMBASE    = 779, 
    STADIUM        = 784, 
    // Last tile stadium 794.

    // tile 785 -- 799 ?
    FULLSTADIUM    = 800,
    // tile 801 -- 810 ?

    // Nuclear power plant (4x4).
    NUCLEARBASE    = 811, 
    NUCLEAR        = 816, 
    LASTZONE       = 826, 

    LIGHTNINGBOLT  = 827,
    HBRDG0         = 828,
    HBRDG1         = 829,
    HBRDG2         = 830,
    HBRDG3         = 831,
    HBRDG_END      = 832,
    RADAR0         = 832,
    RADAR1         = 833,
    RADAR2         = 834,
    RADAR3         = 835,
    RADAR4         = 836,
    RADAR5         = 837,
    RADAR6         = 838,
    RADAR7         = 839,
    FOUNTAIN       = 840,
    // tile 841 -- 843: fountain animation.
    INDBASE2       = 844,
    TELEBASE       = 844,
    // tile 845 -- 850 ?
    TELELAST       = 851,
    SMOKEBASE      = 852,
    // tile 853 -- 859 ?
    TINYEXP        = 860,
    // tile 861 -- 863 ?
    SOMETINYEXP    = 864,
    // tile 865 -- 866 ?
    LASTTINYEXP    = 867,
    // tile 868 -- 882 ?
    TINYEXPLAST    = 883,
    // tile 884 -- 915 ?

    COALSMOKE1     = 916, 


    COALSMOKE2     = 920, 


    COALSMOKE3     = 924, 


    COALSMOKE4     = 928, 


    FOOTBALLGAME1  = 932,
    // tile 933 -- 939 ?
    FOOTBALLGAME2  = 940,
    // tile 941 -- 947 ?
    VBRDG0         = 948,
    VBRDG1         = 949,
    VBRDG2         = 950,
    VBRDG3         = 951,

    NUKESWIRL1     = 952,
    NUKESWIRL2     = 953,
    NUKESWIRL3     = 954,
    NUKESWIRL4     = 955,

    // Tiles 956-959 unused (originally)
//    TILE_COUNT     = 960,

    // Extended zones: 956-1019

    CHURCH1BASE    = 956,
    CHURCH1        = 960,
    CHURCH2BASE    = 965,
    CHURCH2        = 969,
    CHURCH3BASE    = 974,
    CHURCH3        = 978,
    CHURCH4BASE    = 983,
    CHURCH4        = 987,
    CHURCH5BASE    = 992,
    CHURCH5        = 996,
    CHURCH6BASE    = 1001,
    CHURCH6        = 1005,
    CHURCH7BASE    = 1010,
    CHURCH7        = 1014,
    CHURCH7LAST    = 1018,

    // Tiles 1020-1023 unused

    TILE_COUNT     = 1024,

    TILE_INVALID   = -1, 
};

enum EditingTool {
    TOOL_RESIDENTIAL,
    TOOL_COMMERCIAL,
    TOOL_INDUSTRIAL,
    TOOL_FIRESTATION,
    TOOL_POLICESTATION,
    TOOL_QUERY,
    TOOL_WIRE,
    TOOL_BULLDOZER,
    TOOL_RAILROAD,
    TOOL_ROAD,
    TOOL_STADIUM,
    TOOL_PARK,
    TOOL_SEAPORT,
    TOOL_COALPOWER,
    TOOL_NUCLEARPOWER,
    TOOL_AIRPORT,
    TOOL_NETWORK,
    TOOL_WATER,
    TOOL_LAND,
    TOOL_FOREST,

    TOOL_COUNT,
    TOOL_FIRST = TOOL_RESIDENTIAL,
    TOOL_LAST = TOOL_FOREST,
};


// Scenarios

enum Scenario {
    SC_NONE,           

    SC_DULLSVILLE,     
    SC_SAN_FRANCISCO,  
    SC_HAMBURG,        
    SC_BERN,           
    SC_TOKYO,          
    SC_DETROIT,        
    SC_BOSTON,         
    SC_RIO,            

    SC_COUNT,          
};


// Zones

enum ZoneType {
    ZT_COMMERCIAL,       
    ZT_INDUSTRIAL,       
    ZT_RESIDENTIAL,      

    ZT_NUM_DESTINATIONS, 
};


// City problems

enum CityVotingProblems {
    CVP_CRIME,                    
    CVP_POLLUTION,                
    CVP_HOUSING,                  
    CVP_TAXES,                    
    CVP_TRAFFIC,                  
    CVP_UNEMPLOYMENT,             
    CVP_FIRE,                     

    CVP_NUMPROBLEMS,              

    CVP_PROBLEM_COMPLAINTS = 4,   

    PROBNUM = 10,
};

enum CityClass {
    CC_VILLAGE,     
    CC_TOWN,        
    CC_CITY,        
    CC_CAPITAL,     
    CC_METROPOLIS,  
    CC_MEGALOPOLIS, 

    CC_NUM_CITIES,  
};

enum GameLevel {
    LEVEL_EASY,   
    LEVEL_MEDIUM, 
    LEVEL_HARD,   

    LEVEL_COUNT,  

    LEVEL_FIRST = LEVEL_EASY, 
    LEVEL_LAST  = LEVEL_HARD, 
};

// Inline functions

// min/max won't compile on Win32 platform as it's already part of stdlib
#ifndef _WIN32

template <typename T>
static inline T min(const T a, const T b)
{
    return (a < b) ? a : b;
}

template <typename T>
static inline T max(const T a, const T b)
{
    return (a > b) ? a : b;
}

#endif // _WIN32

template <typename T>
static inline T clamp(const T val, const T lower, const T upper)
{
    if (val < lower) {
        return lower;
    }
    if (val > upper) {
        return upper;
    }
    return val;
}

template <typename T>
static inline T absoluteValue(const T val)
{
  if (val < 0) {
        return -val;
    }
    return val;
}

// Macros


#define LENGTH_OF(array) (sizeof(array) / sizeof((array)[0]))

#define NOT_REACHED() not_reached(__LINE__, __FILE__)


static inline void not_reached(int line, const char *fname)
{
    fprintf(stderr, "Code unexpectedly executed at line %d, at file %s\n", line, fname);
    exit(1);
}


// Forward class definitions


class Micropolis;
class ToolEffects;
class BuildingProperties;


// Typedefs


// This is the signature of the scripting language independent
// callback function.
typedef void (*CallbackFunction)(
    Micropolis *micropolis,
    void *data,
    const char *name,
    const char *params,
    va_list arglist);


// Classes


class Resource {

public:

    char *buf; 
    Quad size; 
    char name[4]; 
    Quad id; 
    Resource *next; 
};


class StringTable {

public:

    Quad id; 
    int lines; 
    char **strings; 
    StringTable *next; 
};


class SimSprite {

public:

    SimSprite *next; 
    char *name; 
    int type; 
    int frame; 
    int x; 
    int y; 
    int width;
    int height;
    int xOffset;
    int yOffset;
    int xHot; 
    int yHot; 
    int origX;
    int origY;
    int destX; 
    int destY; 
    int count;
    int soundCount;
    int dir;
    int newDir;
    int step;
    int flag;
    int control;
    int turn;
    int accel;
    int speed;
};


class Micropolis {


public:




    Micropolis();

    ~Micropolis();

private:

    void init();

    void destroy();


    // allocate.cpp

public:


    short roadTotal;

    short railTotal;

    short firePop;

    short resPop;

    short comPop;

    short indPop;

    short totalPop;

    short totalPopLast;

    short resZonePop; 
    short comZonePop; 
    short indZonePop; 

    short totalZonePop;

    short hospitalPop; 
    short churchPop; 
    short faith; 
    short stadiumPop; 

    short policeStationPop;

    short fireStationPop;

    short coalPowerPop;

    short nuclearPowerPop;

    short seaportPop;

    short airportPop;

    short crimeAverage;

    short pollutionAverage;

    short landValueAverage;


    Quad cityTime;

    Quad cityMonth;

    Quad cityYear;

    short startingYear;


    /* Maps */

    unsigned short *map[WORLD_W];

    short resHist10Max;

    short resHist120Max;

    short comHist10Max;

    short comHist120Max;

    short indHist10Max;

    short indHist120Max;

    bool censusChanged;


    Quad roadSpend;

    Quad policeSpend;

    Quad fireSpend;

    Quad roadFund;

    Quad policeFund;

    Quad fireFund;

    Quad roadEffect;

    Quad policeEffect;

    Quad fireEffect;

    Quad taxFund;

    short cityTax;

    bool taxFlag;



    MapByte2 populationDensityMap; 
    MapByte2 trafficDensityMap; 
    MapByte2 pollutionDensityMap; 
    MapByte2 landValueMap; 
    MapByte2 crimeRateMap; 

    MapByte4 terrainDensityMap;

    MapByte2 tempMap1;

    MapByte2 tempMap2;

    MapByte4 tempMap3;

    MapByte1 powerGridMap;

    MapShort8 rateOfGrowthMap;

    MapShort8 fireStationMap;

    MapShort8 fireStationEffectMap;

    MapShort8 policeStationMap;

    MapShort8 policeStationEffectMap;

    MapShort8 comRateMap;




    short *resHist;

    short *comHist;

    short *indHist;

    short *moneyHist;

    short *pollutionHist;

    short *crimeHist;

    short *miscHist;



private:

    short needHospital;

    short needChurch;


    unsigned short *mapBase;


    void initMapArrays();

    void destroyMapArrays();


    // animate.cpp

public:


    void animateTiles();

    static int getNextAnimatedTile(int index);


    // budget.cpp

public:


    float roadPercent;

    float policePercent;

    float firePercent;

    Quad roadValue;

    Quad policeValue;

    Quad fireValue;

    int mustDrawBudget;


    void initFundingLevel();

    void doBudget();

    void doBudgetFromMenu();

    void doBudgetNow(bool fromMenu);

    void updateBudget();

    void showBudgetWindowAndStartWaiting();

    void setCityTax(short tax);


    // connect.cpp

private:


    ToolResult connectTile(short x, short y,
                           ConnectTileCommand cmd, ToolEffects *effects);

    ToolResult layDoze(int x, int y, ToolEffects *effects);

    ToolResult layRoad(int x, int y, ToolEffects *effects);

    ToolResult layRail(int x, int y, ToolEffects *effects);

    ToolResult layWire(int x, int y, ToolEffects *effects);

    void fixZone(int x, int y, ToolEffects *effects);

    void fixSingle(int x, int y, ToolEffects *effects);


    // disasters.cpp

public:


    short floodCount;


    void makeMeltdown();

    void makeFireBombs();

    void makeEarthquake();

    void makeFire();

    void makeFlood();

    void setFire();

    void fireBomb();

  private:

    void doDisasters();

    void scenarioDisaster();

    bool vulnerable(int tem);

    void doFlood(const Position &pos);


    // evaluate.cpp

public:


    short cityYes;

    short problemVotes[PROBNUM];

    short problemOrder[CVP_PROBLEM_COMPLAINTS];

    Quad cityPop;

    Quad cityPopDelta;

    Quad cityAssessedValue;

    CityClass cityClass; 

    short cityScore;

    short cityScoreDelta;

    short trafficAverage;


    void cityEvaluation();

    void evalInit();

    void doScoreCard();

    void changeEval();

    void scoreDoer();

    int countProblems();

    int getProblemNumber(int i);

    int getProblemVotes(int i);


private:

    void getAssessedValue();

    void doPopNum();

    Quad getPopulation();
    CityClass getCityClass(Quad cityPop);

    void doProblems(short problemTable[PROBNUM]);

    void voteProblems(const short problemTable[PROBNUM]);

    short getTrafficAverage();

    short getUnemployment();

    short getFireSeverity();

    void getScore(const short problemTable[PROBNUM]);

    void doVotes();

    // fileio.cpp

public:


    bool loadFileDir(const char *filename, const char *dir);

    bool loadFile(const char *filename);

    bool saveFile(const char *filename);

    void loadScenario(Scenario s);

    void didLoadScenario();

    bool loadCity(const char *filename);

    void didLoadCity();

    void didntLoadCity(const char *msg);

    void saveCity();

    void doSaveCityAs();

    void didSaveCity();

    void didntSaveCity(const char *msg);

    void saveCityAs(const char *filename);


    // generate.cpp

public:


    int terrainTreeLevel;

    int terrainLakeLevel;

    int terrainCurveLevel;

    int terrainCreateIsland;


    void generateMap() ;

    void clearMap();

    void clearUnnatural();

    void makeIsland();

    void treeSplash(short xloc, short yloc);

    void makeSingleLake(const Position &pos);

    void plopBRiver(const Position &pos);
    void plopSRiver(const Position &pos);

    void generateSomeCity(int seed);

private:

    void generateMap(int seed);

    void makeNakedIsland();

    void doTrees();

    bool isTree(MapValue cell);

    void smoothTrees();

    void smoothTreesAt(int x, int y, bool preserve);
    void smoothTreesAt(int x, int y, bool preserve, ToolEffects *effects);

    void makeLakes();

    void doRivers(const Position &terrainPos);

    Direction2 doBRiver(const Position &riverPos,
                        Direction2 riverDir, Direction2 terrainDir);
    Direction2 doSRiver(const Position &riverPos,
                        Direction2 riverDir, Direction2 terrainDir);

    void smoothRiver();

    void smoothWater();

    void putOnMap(MapValue mChar, short xLoc, short yLoc);


    // graph.cpp

public:


    bool historyInitialized;

    short graph10Max;

    short graph120Max;


    void drawMonth(short *hist, unsigned char *s, float scale);

    void changeCensus();

    void graphDoer();

    void initGraphs();

    void initGraphMax();

#ifdef SWIG
// This tells SWIG that minValResult, maxValResult are output parameters,
// which will be returned in a tuple of length two.
%apply short *OUTPUT { short *minValResult };
%apply short *OUTPUT { short *maxValResult };
#endif

    void getHistoryRange(int historyType, int historyScale,
                         short *minValResult, short *maxValResult);

    short getHistory(int historyType, int historyScale,
                     int historyIndex);

    void setHistory(int historyType, int historyScale,
                    int historyIndex, short historyValue);


    // initialize.cpp

private:


    void initWillStuff();

    void resetMapState();

    void resetEditorState();


    // main.cpp

public:


    int simLoops;

    int simPasses;

    int simPass;

    bool simPaused;

    int simPausedSpeed;

    bool tilesAnimated; 

    bool doAnimation;

    bool doMessages; 

    bool doNotices; 


    const char *getMicropolisVersion();

    void simUpdate();

    void simTick();

    void simRobots();

public:

    std::string cityFileName; 

    std::string cityName;     

private:

    int heatSteps;

    int heatFlow;

    int heatRule;

    int heatWrap;

    short *cellSrc;

    short *cellDst;


    void environmentInit();

    void simInit();

    void simHeat();

    void simLoop(bool doSim);


#if 0

    // map.cpp
    //
    // Disabled this small map drawing, filtering and overlaying code.
    // Going to re-implement it in the tile engine and Python.

public:


    int dynamicData[32]; // Read-only, it seems


    void drawAll();

    void drawRes();

    void drawCom();

    void drawInd();

    void drawLilTransMap();

    void drawPower();

    bool dynamicFilter(int col, int row);

    void drawDynamic();

    short getCI(short x);

    void drawPopulationDensity();

    void drawRateOfGrowth();

    void drawTrafficDensityMap();

    void drawPollutionDensityMap();

    void drawCrimeRateMap();

    void drawLandValueMap();

    void drawFireRadius();

    void drawPoliceRadius();

    void memDrawMap();

    void ditherMap();

    void maybeDrawRect(
        int val,
        int x,
        int y,
        int w,
        int h);

    void drawRect(
        int pixel,
        int solid,
        int x,
        int y,
        int w,
        int h);

#endif


    // message.cpp

public:


    Quad cityPopLast;   
    short categoryLast; 

    bool autoGoto;


    void sendMessages();

    void checkGrowth();

    void doScenarioScore(Scenario type);

    void sendMessage(
        short Mnum,
        short x=NOWHERE, short y=NOWHERE,
        bool picture=false, bool important=false);

    void doMakeSound(int mesgNum, int x, int y);

    void doAutoGoto(short x, short y, char *msg);

    void doLoseGame();
    void doWinGame(); 


    // power.cpp

private:



    int powerStackPointer; 

    Position powerStackXY[POWER_STACK_SIZE];


    void doPowerScan();

    bool testForConductive(const Position &pos, Direction2 testDir);

    void pushPowerStack(const Position &pos);

    Position pullPowerStack();



    // random.cpp

private:


    UQuad nextRandom;


    int simRandom();

    short getRandom(short range);

    int getRandom16();

    int getRandom16Signed();

    short getERandom(short limit);

    void randomlySeedRandom();

    void seedRandom(int seed);


    // resource.cpp

public:


    std::string homeDir;

    std::string resourceDir;

    Resource *resources; 
    StringTable *stringTables; 


    Resource *getResource(const char *name, Quad id);

    void getIndString(char *str, int id, short num);


    // scan.cpp

private:


    short newMap;

    short newMapFlags[MAP_TYPE_COUNT];

    short cityCenterX; 
    short cityCenterY; 

    short pollutionMaxX; 
    short pollutionMaxY; 

    short crimeMaxX; 
    short crimeMaxY; 

    Quad donDither;


    void fireAnalysis();

    void populationDensityScan();

    int getPopulationDensity(const Position &pos, MapTile tile);

    void pollutionTerrainLandValueScan();

    int getPollutionValue(int loc);

    int getCityCenterDistance(int x, int y);

    void crimeScan();

    void smoothTerrain();

    void doSmooth1();

    void doSmooth2();

    void computeComRateMap();

    // simulate.cpp

public:


    bool valveFlag;

    short crimeRamp;

    short pollutionRamp;

    bool resCap; 
    bool comCap; 
    bool indCap; 

    short cashFlow;

    float externalMarket;

    Scenario disasterEvent; 
    short disasterWait; 

    Scenario scoreType; 
    short scoreWait; 

    short poweredZoneCount; 
    short unpoweredZoneCount; 

    bool newPower; /* post */

    short cityTaxAverage;

    short simCycle;

    short phaseCycle;

    short speedCycle;

    bool doInitialEval; 

    int mapSerial; 

private:

    short resValve;
    short comValve;
    short indValve;


public:

    void updateFundEffects();


private:

    inline MapValue randomFire()
    {
        return (FIRE + (getRandom16() & 7)) | ANIMBIT;
    };

    inline MapValue randomRubble()
    {
        return (RUBBLE + (getRandom16() & 3)) | BULLBIT;
    };

    void simFrame();

    void simulate();

    void doSimInit();

    void doNilPower();

    void decTrafficMap();

    void decRateOfGrowthMap();

    void initSimMemory();

    void simLoadInit();

    void setCommonInits();

    void setValves();

    void clearCensus();

    void take10Census();

    void take120Census();

    void collectTax();

    void mapScan(int x1, int x2);

    void doRail(const Position &pos);

    void doRadTile(const Position &pos);

    void doRoad(const Position &pos);

    bool doBridge(const Position &pos, MapTile tile);

    int getBoatDistance(const Position &pos);

    void doFire(const Position &pos);

    void fireZone(const Position &pos, MapValue ch);

    void repairZone(const Position &pos, MapTile zCent, short zSize);

    void doSpecialZone(const Position &pos, bool PwrOn);

    void drawStadium(const Position &center, MapTile z);

    void doAirport(const Position &pos);

    void coalSmoke(const Position &pos);

    void doMeltdown(const Position &pos);


    // sprite.cpp

public:


    SimSprite *spriteList; 


    SimSprite *newSprite(const char *name, int type, int x, int y);

    void initSprite(SimSprite *sprite, int x, int y);

    void destroyAllSprites();

    void destroySprite(SimSprite *sprite);

    SimSprite *getSprite(int type);

    SimSprite *makeSprite(int type, int x, int y);


private:

    SimSprite *freeSprites; 

    SimSprite *globalSprites[SPRITE_COUNT];

    int absDist;

    short spriteCycle;


public:

    short getChar(int x, int y);

    short turnTo(int p, int d);

    bool tryOther(int Tpoo, int Told, int Tnew);

    bool spriteNotInBounds(SimSprite *sprite);

    short getDir(int orgX, int orgY, int desX, int desY);

    int getDistance(int x1, int y1, int x2, int y2);

    bool checkSpriteCollision(SimSprite *s1, SimSprite *s2);

    void moveObjects();

    void doTrainSprite(SimSprite *sprite);

    void doCopterSprite(SimSprite *sprite);

    void doAirplaneSprite(SimSprite *sprite);

    void doShipSprite(SimSprite *sprite);

    void doMonsterSprite(SimSprite *sprite);

    void doTornadoSprite(SimSprite *sprite);

    void doExplosionSprite(SimSprite *sprite);

    void doBusSprite(SimSprite *sprite);

    int canDriveOn(int x, int y);

    void explodeSprite(SimSprite *sprite);

    bool checkWet(int x);

    void destroyMapTile(int ox, int oy);

    void startFireInZone(int Xloc, int Yloc, int ch);

    void startFire(int x, int y);

    void generateTrain(int x, int y);

    void generateBus(int x, int y);

    void generateShip();

    void makeShipHere(int x, int y);

    void makeMonster();

    void makeMonsterAt(int x, int y);

    void generateCopter(const Position &pos);

    void generatePlane(const Position &pos);

    void makeTornado();

    void makeExplosion(int x, int y);

    void makeExplosionAt(int x, int y);


    // stubs.cpp

public:


    Quad totalFunds; 

    bool autoBulldoze;

    bool autoBudget;

    Quad messageTimeLast;

    GameLevel gameLevel; 

    short initSimLoad;

    Scenario scenario; 

    short simSpeed;

    short simSpeedMeta;

    bool enableSound; 

    bool enableDisasters; 

    short messageNumber;

    bool evalChanged; 

    short blinkFlag;

    CallbackFunction callbackHook;

    void *callbackData;

    void *userData;


    static inline bool testBounds(int wx, int wy)
    {
        return (wx >= 0 && wx < WORLD_W && wy >= 0 && wy < WORLD_H);
    };

    void spend(int dollars);

    void setFunds(int dollars);

    Quad tickCount();

    Ptr newPtr(int size);

    void freePtr(void *data);

    void doPlayNewCity();

    void doReallyStartGame();

    void doStartLoad();

    void doStartScenario(int scenario);

    void initGame();

    void callback(const char *name, const char *params, ...);

    void doEarthquake(int strength);

    void invalidateMaps();

    void makeSound(
      const char *channel,
      const char *sound,
      int x=-1,
      int y=-1);

    // Map

    int getTile(int x, int y);

    void setTile(int x, int y, int tile);

    void *getMapBuffer();

    // Residential.

    // Commercial.

    // Industrial.

    // Power.

    int getPowerGrid(int x, int y);

    void setPowerGrid(int x, int y, int power);

    void *getPowerGridMapBuffer();

    // Roads.

    // Population density.

    int getPopulationDensity(int x, int y);

    void setPopulationDensity(int x, int y, int density);

    void *getPopulationDensityMapBuffer();

    // Rate of growth.

    int getRateOfGrowth(int x, int y);

    void setRateOfGrowth(int x, int y, int rate);

    void *getRateOfGrowthMapBuffer();

    // Traffic density.

    int getTrafficDensity(int x, int y);

    void setTrafficDensity(int x, int y, int density);

    void *getTrafficDensityMapBuffer();

    // Pollution density.

    int getPollutionDensity(int x, int y);

    void setPollutionDensity(int x, int y, int density);

    void *getPollutionDensityMapBuffer();

    // Crime rate.

    int getCrimeRate(int x, int y);

    void setCrimeRate(int x, int y, int rate);

    void *getCrimeRateMapBuffer();

    // Land value.

    int getLandValue(int x, int y);

    void setLandValue(int x, int y, int value);

    void *getLandValueMapBuffer();

    // Fire coverage.

    int getFireCoverage(int x, int y);

    void setFireCoverage(int x, int y, int coverage);

    void *getFireCoverageMapBuffer();

    // Police coverage.

    int getPoliceCoverage(int x, int y);

    void setPoliceCoverage(int x, int y, int coverage);

    void *getPoliceCoverageMapBuffer();


    // tool.cpp

public:

    ToolResult doTool(EditingTool tool, short tileX, short tileY);

    void toolDown(EditingTool tool, short tileX, short tileY);

    void toolDrag(EditingTool tool, short fromX, short fromY,
                                    short toX, short toY);

    void didTool(const char *name, short x, short y);

private:

    ToolResult queryTool(short x, short y);

    ToolResult bulldozerTool(short x, short y);
    ToolResult bulldozerTool(short x, short y, ToolEffects *effects);

    ToolResult roadTool(short x, short y, ToolEffects *effects);

    ToolResult railroadTool(short x, short y, ToolEffects *effects);

    ToolResult wireTool(short x, short y, ToolEffects *effects);

    ToolResult parkTool(short x, short y, ToolEffects *effects);

    ToolResult buildBuildingTool(short x, short y,
                                  const BuildingProperties *bprops,
                                  ToolEffects *effects);


    ToolResult networkTool(short x, short y, ToolEffects *effects);

    ToolResult waterTool(short x, short y, ToolEffects *effects);

    ToolResult landTool(short x, short y, ToolEffects *effects);

    ToolResult forestTool(short x, short y, ToolEffects *effects);

    ToolResult putDownPark(short mapH, short mapV, ToolEffects *effects);

    ToolResult putDownNetwork(short mapH, short mapV, ToolEffects *effects);

    ToolResult putDownWater(short mapH, short mapV, ToolEffects *effects);

    ToolResult putDownLand(short mapH, short mapV, ToolEffects *effects);

    ToolResult putDownForest(short mapH, short mapV, ToolEffects *effects);

    void doZoneStatus(short mapH, short mapV);

    void doShowZoneStatus(
        char *str,
        char *s0, char *s1, char *s2, char *s3, char *s4,
        int x, int y);

    void putBuilding(int leftX, int topY, int sizeX, int sizeY,
                     MapTile baseTile, bool aniFlag,
                     ToolEffects *effects);

    ToolResult prepareBuildingSite(int leftX, int topY, int sizeX, int sizeY,
                                   ToolEffects *effects);

    ToolResult buildBuilding(int mapH, int mapV,
                                  const BuildingProperties *bprops,
                                  ToolEffects *effects);

    int getDensityStr(short catNo, short mapH, short mapV);

    bool tally(short tileValue);

    short checkSize(short tileValue);

    void checkBorder(short xMap, short yMap, int sizeX, int sizeY,
                     ToolEffects *effects);

    void putRubble(int x, int y, int size, ToolEffects *effects);


    // traffic.cpp

public:

    short makeTrafficAt(int x, int y, ZoneType dest);

    short makeTraffic(int x, int y, ZoneType dest);


private:

    short makeTraffic(const Position &startPos, ZoneType dest);

    /* Position stack */

    short curMapStackPointer;
    Position curMapStackXY[MAX_TRAFFIC_DISTANCE + 1]; 

    short trafMaxX; 
    short trafMaxY; 


    void addToTrafficDensityMap();

    void pushPos(const Position &pos);

    Position pullPos();

    bool findPerimeterRoad(Position *pos);

    bool findPerimeterTelecom(const Position &pos);

    bool tryDrive(const Position &startPos, ZoneType destZone);

    Direction2 tryGo(const Position &pos, Direction2 dirLast);

    MapTile getTileFromMap(const Position &pos,
                            Direction2 dir, MapTile defaultTile);

    bool driveDone(const Position &pos, ZoneType destZone);

    bool roadTest(MapValue tile);


    // update.cpp

public:


    bool mustUpdateFunds;

    bool mustUpdateOptions; 

    Quad cityTimeLast;

    Quad cityYearLast;

    Quad cityMonthLast;

    Quad totalFundsLast;

    Quad resLast;

    Quad comLast;

    Quad indLast;


    void doUpdateHeads();

    void updateMaps();

    void updateGraphs();

    void updateEvaluation();

    void updateHeads();

    void updateFunds();

    void reallyUpdateFunds();

    void doTimeStuff();

    void updateDate();

    void showValves();

    void drawValve();

    void setDemand(float r, float c, float i);

    void updateOptions();

    void updateUserInterface();


    // utilities.cpp

public:

    void pause();

    void resume();

    void setSpeed(short speed);

    void setPasses(int passes);

    void setGameLevelFunds(GameLevel level);

    void setGameLevel(GameLevel level);

    void updateGameLevel();

    void setCityName(const std::string &name);

    void setCleanCityName(const std::string &name);

    void setYear(int year);

    int currentYear();

    void doNewGame();

    void setEnableDisasters(bool value);

    void setAutoBudget(bool value);

    void setAutoBulldoze(bool value);

    void setAutoGoto(bool value);

    void setEnableSound(bool value);

    void setDoAnimation(bool value);

    void setDoMessages(bool value);

    void setDoNotices(bool value);

#ifdef SWIG
// This tells SWIG that resDemandResult, comDemandResult and indDemandResult
// are output parameters, which will be returned in a tuple of length three.
%apply float *OUTPUT { float *resDemandResult };
%apply float *OUTPUT { float *comDemandResult };
%apply float *OUTPUT { float *indDemandResult };
#endif

    void getDemands(
        float *resDemandResult,
        float *comDemandResult,
        float *indDemandResult);


private:

    void makeDollarDecimalStr(char *numStr, char *dollarStr);


    // zone.cpp

private:


    void doZone(const Position &pos);

    void doHospitalChurch(const Position &pos);

    void setSmoke(const Position &pos, bool zonePower);

    void makeHospital(const Position &pos);

    short getLandPollutionValue(const Position &pos);

    void incRateOfGrowth(const Position &pos, int amount);

    bool zonePlop(const Position &pos, int base);

    short doFreePop(const Position &pos);

    bool setZonePower(const Position& pos);

    void buildHouse(const Position &pos, int value);

    short evalLot(int x, int y);

    void doResidential(const Position &pos, bool zonePower);

    void doResIn(const Position &pos, int pop, int value);

    void doResOut(const Position &pos, int pop, int value);

    short getResZonePop(MapTile mapTile);

    void resPlop(const Position &pos, int Den, int Value);

    short evalRes(const Position &pos, int traf);

    // Commercial zone handling

    void doCommercial(const Position &pos, bool zonePower);

    void doComIn(const Position &pos, int pop, int value);

    void doComOut(const Position &pos, int pop, int value);

    short getComZonePop(MapTile tile);

    void comPlop(const Position &pos, int Den, int Value);

    short evalCom(const Position &pos, int traf);

    // Industrial zone handling

    void doIndustrial(const Position &pos, bool zonePower);

    void doIndIn(const Position &pos, int pop, int value);

    void doIndOut(const Position &pos, int pop, int value);

    short getIndZonePop(MapTile tile);

    void indPlop(const Position &pos, int den, int value);

    short evalInd(int traf);




};

---