---

source/globals.c

Go to the documentation of this file.

#include <config.h>

#include <zakdef.h>
#if defined(PALM)
#include <StringMgr.h>
#include <unix_stdio.h>
#else
#include <stdio.h>
#endif
#include <mem_compat.h>
#include <logging.h>
#include <locking.h>
#include <ui.h>
#include <stack.h>
#include <globals.h>

#define MILLION 1000000

stat_to_value statvalues[] = {
        { st_cashflow, bc_cashflow },
        { st_pollution, bc_pollution },
        { st_crime, bc_crime },
        { st_residential, bc_value_residential },
        { st_commercial, bc_value_commercial }, 
        { st_industrial, bc_value_industrial },
        { st_tail, 0 }
};

GameStruct game;
vGameStruct vgame;

vGameVisuals visuals;

void *worldPtr;
void *flagPtr;

void *growablePtr;

AppConfig_t gameConfig = {
        CONFIG_VERSION,
        DEFAULT_APPCONFIG
};

static UInt16 needchange;

void
addGraphicUpdate(graphicupdate_t entity)
{
        if (entity != gu_all)
                needchange |= (UInt16)entity;
        else
                needchange = ~(UInt16)0;
}

void
removeGraphicUpdate(graphicupdate_t entity)
{
        needchange &= ~((UInt16)entity);
}

UInt8
checkGraphicUpdate(graphicupdate_t entity)
{
        return ((UInt8)(needchange & entity ? 1 : 0));
}

UInt8
checkAnyGraphicUpdate(void)
{
        return ((UInt8)(needchange ? 1 : 0));
}

void
clearGraphicUpdate(void)
{
        needchange = 0;
}

char *
getDate(char *temp)
{
        char month[10];

        sprintf(temp, "%s %ld", getMonthString(
            (UInt16)(getMonthsElapsed() % 12),
            month, (UInt16)9),
            (long)((getMonthsElapsed() / 12) + 2000));
        return ((char *)temp);
}

void *
getIndexOf(char *ary, Int16 addit, Int16 key)
{
        while (*(Int16 *)ary) {
                if (key == *(Int16 *)ary)
                        return (ary);
                ary += addit;
        }
        return (NULL);
}

UInt8
getDisasterLevel(void)
{
        return ((UInt8)(GG.diff_disaster & 0xF));
}

void
setDisasterLevel(UInt8 value)
{
        GG.diff_disaster &= 0xf0;
        GG.diff_disaster |= (UInt8)(value & 0x0f);
}

UInt8
getDifficultyLevel(void)
{
        return ((UInt8)((GG.diff_disaster >> 4) & 0x0f));
}

void
setDifficultyLevel(UInt8 value)
{
        GG.diff_disaster &= (UInt8)0x0f;
        GG.diff_disaster |= (UInt8)((value & 0x0f) << 4);
}

Int16
ResizeWorld(UInt32 size)
{
        WriteLog("Resize World = %ld\n", (long)size);
        LockZone(lz_world);
        LockZone(lz_flags);
        worldPtr = gRealloc(worldPtr, size);
        flagPtr = gRealloc(flagPtr, size);

        if (worldPtr == NULL) {
                UISystemErrorNotify(seOutOfMemory);
                WriteLog("realloc failed - resizeworld\n");
                return (0);
        }
        if (flagPtr == NULL) {
                UISystemErrorNotify(seOutOfMemory);
                WriteLog("realloc failed - resizeworldflags\n");
                return (0);
        }

        gMemSet(worldPtr, (Int32)size, 0);
        gMemSet(flagPtr, (Int32)size, 0);
        UnlockZone(lz_world);
        UnlockZone(lz_flags);
        return (1);
}

Int16
InitWorld(void)
{
        return (1);
}

welem_t
getWorld(UInt32 pos)
{
        if (pos > MapMul())
                return (0);
                
        return (((welem_t *)worldPtr)[pos]);
}

void
setWorld(UInt32 pos, welem_t value)
{
        if (pos > MapMul())
                return;

        ((welem_t *)worldPtr)[pos] = value;
}

void
setWorldAndFlag(UInt32 pos, welem_t value, selem_t status)
{
        if (pos > MapMul())
                return;

        ((welem_t *)worldPtr)[pos] = value;
        ((selem_t *)flagPtr)[pos] = status;
}

selem_t
getWorldFlags(UInt32 pos)
{
        if (pos > MapMul())
                return (0);
        return (((selem_t *)flagPtr)[pos]);
}

void
setWorldFlags(UInt32 pos, selem_t value)
{
        if (pos > MapMul())
                return;
        ((selem_t *)flagPtr)[pos] = value;
}

void
andWorldFlags(UInt32 pos, selem_t value)
{
        if (pos > MapMul())
                return;
        ((selem_t *)flagPtr)[pos] &= value;
}

void
orWorldFlags(UInt32 pos, selem_t value)
{
        if (pos > MapMul())
                return;
        ((selem_t *)flagPtr)[pos] |= value;
}

void
getWorldAndFlag(UInt32 pos, welem_t *world, selem_t *flag)
{
        if (pos > MapMul())
                return;
        *world = ((welem_t *)worldPtr)[pos];
        *flag = ((selem_t *)flagPtr)[pos];
}

void
PurgeWorld(void)
{
        ReleaseZone(lz_world);
        ReleaseZone(lz_flags);
}

UInt32
scaleNumber(UInt32 old_value, Char *scale)
{
        const char si_scale[] = " KMBTQ";
        const char *at_scale = si_scale;
        while (old_value > MILLION) {
                at_scale++;
                old_value /= 1000;
        }
        *scale = *at_scale;
        return (old_value);
}

void
setGameBit(gamestatusbit_t bit, UInt8 value)
{
        GG.gas_bits &= (~bit & 0xff);
        if (value) GG.gas_bits |= bit;
}

UInt8
getGameBit(gamestatusbit_t bit)
{
        return (GG.gas_bits & bit);
}

---