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.
 */
 
#ifndef H_MICROPOLIS
#define H_MICROPOLIS
 
 
// Includes
 
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <cstdarg>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/types.h>
 
#include <string>
#include <vector>
#include <map>
 
#include <emscripten.h>
#include <emscripten/bind.h>
 
#include "data_types.h"
#include "map_type.h"
#include "position.h"
#include "text.h"
#include "frontendmessage.h"
#include "tool.h"
#include "callback.h"
 
 
// Definitions
 
 
#define IS_INTEL                        1
 
 
// 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;
 
 
static const int ISLAND_RADIUS = 18;
 
 
// 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
 
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 Tiles {
    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
 
    USED_TILE_COUNT = 1019,
    TILE_COUNT      = 1024,
 
    TILE_INVALID   = -1, 
};
 
 
// 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
 
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;
}
 
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 Callback;
class ConsoleCallback;
class ToolEffects;
class BuildingProperties;
 
 
// Classes
 
 
class SimSprite {
 
public:
 
    SimSprite *next; 
    std::string 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();
 
    void setCallback(Callback *callback, emscripten::val callbackVal);
 
    void init();
 
 
private:
 
    void destroy();
 
    // allocate.cpp
 
public:
 
 
    Callback *callback;
 
 
    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];
    unsigned short *mop[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;
    unsigned short *mopBase;
 
 
    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 loadFileData(const std::string &filename);
 
    bool loadFile(const std::string &filename);
 
    bool saveFile(const std::string &filename);
 
    void loadScenario(Scenario s);
 
    void didLoadScenario(int s, const std::string name, const std::string fname);
 
    bool loadCity(const std::string &filename);
 
    void didLoadCity(const std::string &filename);
 
    void didntLoadCity(const std::string &msg);
 
    void saveCity();
 
    void doSaveCityAs(const std::string &filename);
 
    void didSaveCity(const std::string &filename);
 
    void didntSaveCity(const std::string &msg);
 
    void saveCityAs(const std::string &filename);
 
 
    // generate.cpp
 
public:
 
 
    int terrainTreeLevel;
 
    int terrainLakeLevel;
 
    int terrainCurveLevel;
 
    int terrainCreateIsland;
 
    int generatedCitySeed;
 
    void generateSomeRandomCity();
 
    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);
 
    void generateMap(int seed);
 
private:
 
    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();
 
 
    // micropolis.cpp
 
public:
 
 
    int simLoops;
 
    int simPasses;
 
    int simPass;
 
    bool simPaused;
 
    int simPausedSpeed;
 
    bool tilesAnimated; 
 
    bool doAnimation;
 
    bool doMessages; 
 
    bool doNotices; 
 
 
    std::string getMicropolisVersion();
 
    void simUpdate();
 
    void simTick();
 
    void simulateRobots();
 
    long getMapAddress();
 
    long getMapSize();
 
    long getMopAddress();
 
    long getMopSize();
 
public:
 
    std::string cityFileName; 
 
    std::string cityName;     
 
    int heatSteps;
 
    int heatFlow;
 
    int heatRule;
 
    int heatWrap;
 
private:
 
    short *cellSrc;
 
    short *cellDst;
 
 
    void simInit();
 
    void simHeat();
 
    void simLoop(bool doSim);
 
 
    // 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, const std::string &message);
 
    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
 
public:
 
 
    UQuad nextRandom;
 
    int simRandom();
 
    short getRandom(short range);
 
    int getRandom16();
    int getRandom16Signed();
 
    short getERandom(short limit);
 
    void randomlySeedRandom();
 
    void seedRandom(int seed);
 
 
    // scan.cpp
 
public:
 
    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; 
 
public:
 
    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 std::string &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;
 
    emscripten::val callbackVal;
 
    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 doStartScenario(int scenario);
 
    void doStartGame();
 
    void initGame();
 
    void doEarthquake(int strength);
 
    void invalidateMaps();
 
    void makeSound(
      const std::string &channel,
      const std::string &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(std::string 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(
        int tileCategoryIndex,
        int populationDensityIndex,
        int landValueIndex,
        int crimeRateIndex,
        int pollutionIndex,
        int growthRateIndex,
        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 getDensity(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:
 
    std::string makeDollarDecimalStr(const std::string &numStr);
 
 
    // 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);
 
 
 
 
};
 
 
 
 
#endif