fileio.cpp

Go to the documentation of this file.

/* fileio.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"
 
 
 
 
#if !defined(__BIG_ENDIAN__)
 
#define SWAP_SHORTS(buf, len)        swap_shorts(buf, len)
 
#define HALF_SWAP_LONGS(buf, len)    half_swap_longs(buf, len)
 
static void swap_shorts(short *buf, int len)
{
    int i;
 
    /* Flip bytes in each short! */
    for (i = 0; i < len; i++) {
        *buf = ((*buf & 0xFF) <<8) | ((*buf &0xFF00) >>8);
        buf++;
    }
}
 
 
static void half_swap_longs(long *buf, int len)
{
    int i;
 
    /* Flip bytes in each long! */
    for (i = 0; i < len; i++) {
        long l = *buf;
        *buf =
            ((l & 0x0000ffff) << 16) |
            ((l & 0xffff0000) >> 16);
        buf++;
    }
}
 
 
#else
 
 
#define SWAP_SHORTS(buf, len)
 
#define HALF_SWAP_LONGS(buf, len)
 
 
#endif
 
static bool load_short(short *buf, int len, FILE *f)
{
    size_t result = fread(buf, sizeof(short), len, f);
 
    if ((int)result != len) {
         return false;
    }
 
    SWAP_SHORTS(buf, len);        /* to intel */
 
    return true;
}
 
 
static bool save_short(short *buf, int len, FILE *f)
{
    SWAP_SHORTS(buf, len);        /* to MAC */
 
    if ((int)fwrite(buf, sizeof(short), len, f) != len) {
        return false;
    }
 
    SWAP_SHORTS(buf, len);        /* back to intel */
 
    return true;
}
 
bool Micropolis::loadFileData(const std::string &filename)
{
    FILE *f;
    Quad size;
 
    // Open the file.
    f = fopen(filename.c_str(), "rb");
 
    // open() failed; report failure.
    if (f == NULL) {
        return false;
    }
 
    fseek(f, 0L, SEEK_END);
    size = ftell(f);
    fseek(f, 0L, SEEK_SET);
 
    int mapSizeShort = // 12000
      WORLD_W * WORLD_H;
    int mapSize = // 24000
      mapSizeShort * sizeof(short);
    int historySize = // 3120
      (6 * HISTORY_LENGTH) +
       MISC_HISTORY_LENGTH;
    int mapFileSize = // 27120
        historySize + mapSize;
    int mopFileSize = // 51120
        historySize + mapSize + mapSize;
    bool hasMop =
        size == mopFileSize;
    bool isValid =
        hasMop || (size == mapFileSize);
 
    bool result =
      isValid &&
      load_short(resHist, HISTORY_LENGTH / sizeof(short), f) &&
      load_short(comHist, HISTORY_LENGTH / sizeof(short), f) &&
      load_short(indHist, HISTORY_LENGTH / sizeof(short), f) &&
      load_short(crimeHist, HISTORY_LENGTH / sizeof(short), f) &&
      load_short(pollutionHist, HISTORY_LENGTH / sizeof(short), f) &&
      load_short(moneyHist, HISTORY_LENGTH / sizeof(short), f) &&
      load_short(miscHist, MISC_HISTORY_LENGTH / sizeof(short), f) &&
      load_short((short *)mapBase, mapSizeShort, f) &&
      (hasMop 
        ? load_short((short *)mopBase, mapSizeShort, f)
        : true);
 
    //printf("loadFileData: mapSize: %d historySize: %d mapFileSize: %d mopFileSize: %d size: %ld hasMop: %d isValid: %d result: %d\n", mapSize, historySize, mapFileSize, mopFileSize, size, hasMop, isValid, result);
 
    if (!hasMop) {
        memset(mopBase, 0, WORLD_W * WORLD_H * sizeof(short));
    }
 
    fclose(f);
 
    return result;
}
 
bool Micropolis::loadFile(const std::string &filename)
{
    //printf("loadFile: mapBase: %p\n", mapBase);
    long n;
 
    if (!loadFileData(filename)) {
        return false;
    }
 
    /* total funds is a long.....    miscHist is array of shorts */
    /* total funds is being put in the 50th & 51th word of miscHist */
    /* find the address, cast the ptr to a longPtr, take contents */
 
    n = *(Quad *)(miscHist + 50);
    HALF_SWAP_LONGS(&n, 1);
    setFunds(n);
 
    n = *(Quad *)(miscHist + 8);
    HALF_SWAP_LONGS(&n, 1);
    cityTime = n;
 
    setAutoBulldoze(miscHist[52] != 0);   // flag for autoBulldoze
    setAutoBudget(miscHist[53] != 0);     // flag for autoBudget
    setAutoGoto(miscHist[54] != 0);       // flag for auto-goto
    setEnableSound(miscHist[55] != 0);    // flag for the sound on/off
    setCityTax(miscHist[56]);
    //setSpeed(miscHist[57]);
    setSpeed(3); // Naw let's reset the speed to 3 after loading a city.
    changeCensus();
    mustUpdateOptions = true;
 
    /* yayaya */
 
    n = *(Quad *)(miscHist + 58);
    HALF_SWAP_LONGS(&n, 1);
    policePercent = ((float)n) / ((float)65536);
 
    n = *(Quad *)(miscHist + 60);
    HALF_SWAP_LONGS(&n, 1);
    firePercent = (float)n / (float)65536.0;
 
    n = *(Quad *)(miscHist + 62);
    HALF_SWAP_LONGS(&n, 1);
    roadPercent = (float)n / (float)65536.0;
 
    policePercent =
        (float)(*(Quad*)(miscHist + 58)) /
        (float)65536.0;   /* and 59 */
    firePercent =
        (float)(*(Quad*)(miscHist + 60)) /
        (float)65536.0;   /* and 61 */
    roadPercent =
        (float)(*(Quad*)(miscHist + 62)) /
        (float)65536.0;   /* and 63 */
 
    cityTime = max((Quad)0, cityTime);
 
    // If the tax is nonsensical, set it to a reasonable value.
    if (cityTax > 20 || cityTax < 0) {
        setCityTax(7);
    }
 
    // If the speed is nonsensical, set it to a reasonable value.
    if (simSpeed < 0 || simSpeed > 3) {
        simSpeed = 3;
    }
 
    setSpeed(simSpeed);
    setPasses(1);
    initFundingLevel();
 
    // Set the scenario id to 0.
    initWillStuff();
    scenario = SC_NONE;
    initSimLoad = 1;
    doInitialEval = false;
    doSimInit();
    invalidateMaps();
 
    return true;
}
 
 
bool Micropolis::saveFile(const std::string &filename)
{
    long n;
    FILE *f;
 
    if ((f = fopen(filename.c_str(), "wb")) == NULL) {
        return false;
    }
 
    /* total funds is a long.....    miscHist is array of ints */
    /* total funds is bien put in the 50th & 51th word of miscHist */
    /* find the address, cast the ptr to a longPtr, take contents */
 
    n = totalFunds;
    HALF_SWAP_LONGS(&n, 1);
    (*(Quad *)(miscHist + 50)) = n;
 
    n = cityTime;
    HALF_SWAP_LONGS(&n, 1);
    (*(Quad *)(miscHist + 8)) = n;
 
    miscHist[52] = autoBulldoze;   // flag for autoBulldoze
    miscHist[53] = autoBudget;     // flag for autoBudget
    miscHist[54] = autoGoto;       // flag for auto-goto
    miscHist[55] = enableSound;    // flag for the sound on/off
    miscHist[57] = simSpeed;
    miscHist[56] = cityTax;        /* post release */
 
    /* yayaya */
 
    n = (int)(policePercent * 65536);
    HALF_SWAP_LONGS(&n, 1);
    (*(Quad *)(miscHist + 58)) = n;
 
    n = (int)(firePercent * 65536);
    HALF_SWAP_LONGS(&n, 1);
    (*(Quad *)(miscHist + 60)) = n;
 
    n = (int)(roadPercent * 65536);
    HALF_SWAP_LONGS(&n, 1);
    (*(Quad *)(miscHist + 62)) = n;
 
    bool result =
        save_short(resHist, HISTORY_LENGTH / 2, f) &&
        save_short(comHist, HISTORY_LENGTH / 2, f) &&
        save_short(indHist, HISTORY_LENGTH / 2, f) &&
        save_short(crimeHist, HISTORY_LENGTH / 2, f) &&
        save_short(pollutionHist, HISTORY_LENGTH / 2, f) &&
        save_short(moneyHist, HISTORY_LENGTH / 2, f) &&
        save_short(miscHist, MISC_HISTORY_LENGTH / 2, f) &&
        save_short(((short *)&map[0][0]), WORLD_W * WORLD_H, f) &&
        save_short(((short *)&mop[0][0]), WORLD_W * WORLD_H, f);
 
    fclose(f);
 
    return result;
}
 
 
void Micropolis::loadScenario(Scenario s)
{
    std::string name = NULL;
    std::string fname = NULL;
 
    cityFileName = "";
 
    setGameLevel(LEVEL_EASY);
 
    if (s < SC_DULLSVILLE || s > SC_RIO) {
        s = SC_DULLSVILLE;
    }
 
    switch (s) {
        case SC_DULLSVILLE:
            name = "Dullsville";
            fname = "cities/scenario_dullsville.cty";
            scenario = SC_DULLSVILLE;
            cityTime = ((1900 - 1900) * 48) + 2;
            setFunds(5000);
            break;
        case SC_SAN_FRANCISCO:
            name = "San Francisco";
            fname = "cities/scenario_san_francisco.cty";
            scenario = SC_SAN_FRANCISCO;
            cityTime = ((1906 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        case SC_HAMBURG:
            name = "Hamburg";
            fname = "cities/scenario_hamburg.cty";
            scenario = SC_HAMBURG;
            cityTime = ((1944 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        case SC_BERN:
            name = "Bern";
            fname = "cities/scenario_bern.cty";
            scenario = SC_BERN;
            cityTime = ((1965 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        case SC_TOKYO:
            name = "Tokyo";
            fname = "cities/scenario_tokyo.cty";
            scenario = SC_TOKYO;
            cityTime = ((1957 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        case SC_DETROIT:
            name = "Detroit";
            fname = "cities/scenario_detroit.cty";
            scenario = SC_DETROIT;
            cityTime = ((1972 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        case SC_BOSTON:
            name = "Boston";
            fname = "cities/scenario_boston.cty";
            scenario = SC_BOSTON;
            cityTime = ((2010 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        case SC_RIO:
            name = "Rio de Janeiro";
            fname = "cities/scenario_rio_de_janeiro.cty";
            scenario = SC_RIO;
            cityTime = ((2047 - 1900) * 48) + 2;
            setFunds(20000);
            break;
        default:
            NOT_REACHED();
            break;
    }
 
    setCleanCityName(name);
    setSpeed(3);
    setCityTax(7);
 
    loadFileData(fname);
 
    initWillStuff();
    initFundingLevel();
    updateFunds();
    invalidateMaps();
    initSimLoad = 1;
    doInitialEval = false;
    doSimInit();
    didLoadScenario(s, name, fname);
}
 
 
void Micropolis::didLoadScenario(int s, const std::string name, const std::string fname)
{
    callback->didLoadScenario(this, callbackVal, name, fname);
}
 
bool Micropolis::loadCity(const std::string &filename)
{
    if (loadFile(filename)) {
 
        cityFileName = filename;
 
        size_t lastSlash = cityFileName.find_last_of('/');
        size_t pos = (lastSlash == std::string::npos) ? 0 : lastSlash + 1;
 
        size_t lastDot = cityFileName.find_last_of('.');
        size_t last =
            (lastDot == std::string::npos) ? cityFileName.length() : lastDot;
 
        std::string newCityName = cityFileName.substr(pos, last - pos);
        setCityName(newCityName);
 
        doSimInit();
 
        didLoadCity(filename);
 
        return true;
 
    } else {
 
        didntLoadCity(filename);
 
        return false;
 
    }
}
 
void Micropolis::didLoadCity(const std::string &filename)
{
    callback->didLoadCity(this, callbackVal, filename);
}
 
 
void Micropolis::didntLoadCity(const std::string &filename)
{
    callback->didntLoadCity(this, callbackVal, filename);
}
 
 
void Micropolis::saveCity()
{
    if (cityFileName.length() > 0) {
 
        doSaveCityAs(cityFileName);
 
    } else {
        if (saveFile(cityFileName)) {
 
            didSaveCity(cityFileName);
 
        } else {
 
            didntSaveCity(cityFileName);
 
        }
    }
}
 
 
void Micropolis::doSaveCityAs(const std::string &filename)
{
    callback->saveCityAs(this, callbackVal, filename);
}
 
 
void Micropolis::didSaveCity(const std::string &filename)
{
    callback->didSaveCity(this, callbackVal, filename);
}
 
 
void Micropolis::didntSaveCity(const std::string &filename)
{
    callback->didntSaveCity(this, callbackVal, filename);
}
 
 
void Micropolis::saveCityAs(const std::string &filename)
{
    cityFileName = filename;
 
    if (saveFile(cityFileName)) {
 
        size_t lastDot = cityFileName.find_last_of('.');
        size_t lastSlash = cityFileName.find_last_of('/');
 
        size_t pos =
            (lastSlash == std::string::npos) ? 0 : lastSlash + 1;
        size_t last =
            (lastDot == std::string::npos) ? cityFileName.length() : lastDot;
        size_t len =
            last - pos;
        std::string newCityName =
            cityFileName.substr(pos, len);
 
        setCityName(newCityName);
 
        didSaveCity(cityName);
 
    } else {
 
        didntSaveCity(cityFileName);
 
    }
}